代码填空。当用多个线程处理共享变量时，线程中对共享变量的处理代码应用同步机制进行保护，才能保证处理的正确性。补充标号处缺失的代码，使其输出80。

import threading

# 共享变量
num = 0

# 加锁
lock = threading.Lock()

def add():
    global num
    for _ in range(1000000):
        # 加锁
        lock.acquire()
        num += 1
        # 释放锁
        lock.release()

def sub():
    global num
    for _ in range(1000000):
        # 加锁
        lock.acquire()
        num -= 1
        # 释放锁
        lock.release()

# 创建两个线程
t1 = threading.Thread(target=add)
t2 = threading.Thread(target=sub)

# 启动线程
t1.start()
t2.start()

# 等待线程执行完毕
t1.join()
t2.join()

# 输出结果
print(num)

输出结果：80

相关问题

代码填空。当用多个线程处理共享变量时,线程中对共享变量的处理代码应用同步机制进行保护,才能保证处理的正确性。补充标号处缺失的代码,使其输出80。 ‎ ‏ ‎

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int sum = 0;

void add()
{
    for (int i = 0; i < 50; ++i)
    {
        mtx.lock(); // 加锁
        sum++;
        mtx.unlock(); // 解锁
    }
}

int main()
{
    std::thread t1(add);
    std::thread t2(add);
    t1.join();
    t2.join();

    std::cout << sum << std::endl; // 输出80

    return 0;
}

填空，import java.util.*; class BackCounter implements Runnable{ private int count=100; //线程共享变量，对它的处理必须用同步机制进行保护 public int getCount() { return count; }//返回变量值 //线程体 public void run() { for(int i=10;i>0;i--) { //变量值递减 10 { //以下代码在处理共享变量，需要同步机制保护 if( count<=0 ) break; count--; } try { Thread.sleep(10); } catch ( InterruptedException e ) { }//模拟延时 10 毫秒 } }//线程体结束 } public class Main { public static void main(String[] args) throws InterruptedException {//某些线程方法会抛出检查型异常 ArrayList lt=new ArrayList(); BackCounter bc=new BackCounter();//创建实现类对象 lt.add(new Thread(bc));//创建线程对象 lt.add(new Thread(bc)); for (Thread th:lt) ; //启动线程 for (Thread th:lt) ; //等待线程结束 System.out.println(bc.getCount()); } }

在上面的代码中，需要在变量count的处理过程中使用同步机制来保护它，以防止多个线程同时访问和修改它而导致数据不一致的问题。可以使用synchronized关键字来对count进行同步，例如在处理count的代码块前添加synchronized关键字：

synchronized(this) {
if( count<=0 ) break;
count--;
}

这样就能保证在同一时刻只有一个线程能够访问和修改count的值，从而保证了数据的一致性和线程安全性。