Question

我试图学习线程干扰的概念，并在Java Tutorial Oracle中遇到了以下示例：

class Counter {
    private int c = 0;

    public void increment() {
        c++;
    }

    public void decrement() {
        c--;
    }

    public int value() {
        return c;
    }

}

Oracle教程提到如果有两个线程尝试访问变量c，则可能导致线程干扰，而另一个线程所做的更改不会被另一个线程看到。

但是，它没有提供任何代码来实际解释这个概念。有人可以提供一个基于Counter类的代码示例来演示线程干扰是如何实际发生的吗？

Answer 1

而不是代码，我更愿意解释会发生什么。假设2个线程，A和B正在访问相同的计数器对象， A 调用增量和 B 调用递减即可。这些操作中的任何一个至少包含3个步骤。

从内存中读取 C
增加或减少 C
将 C 写回内存。

当A和B同时尝试递增和递减时，一个线程可以从内存读取 C （步骤1），而另一个线程在步骤2 。在这种情况下，如果 c 的初始值为5，则第一个线程A读取并将其递增为6.然后线程B读取并将其递减为4.记住，B在完成写入之前执行这些更改 c 回到记忆中。由于步骤是重叠的，因此一个线程所做的更改对另一个线程不可见，导致 c 的最终值为 6或4 。但实际上我们的预期是 5 。

这是两个线程相互干扰的示例。为避免这种情况，我们使用线程同步。

Answer 2

只需运行代码很多次，其中一次幸运的是，您将能够看到线程干扰的实际效果。

在这种情况下很少观察，因为它是一个小程序，并没有太多发生。如果你进行多次递增和减少线程，线程干扰将更容易观察。

class Counter {
private int c = 0;

public void increment() {c++;}

public void decrement() {c--;}

public int value() {
    return c;
}

public static void main(String[] args) {

    Counter x = new Counter();
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            x.increment();
        }
    };

    Runnable r2 = new Runnable() {
        @Override
        public void run() {
            x.decrement();
        }
    };

    Thread t1 = new Thread(r1);
    Thread t2 = new Thread(r2);     
    t1.start();
    t2.start();
    System.out.println(x.c);

}

}

编辑：我决定添加多线程案例，我无法抗拒

编辑2：这是第二次编辑。多线程案例，因为那是创建超出此问题范围的问题我决定删除它。以前我正在制作一个线程数组并运行它们。相反它会更好显示一个执行大量增量的线程，另一个执行大量减量的线程。

我使用Thread.Sleep（）导致主线程休眠，这将确保在两个线程完成操作后打印c。

class Counter {
private int c = 0;

public void increment() {
    for (int i = 0; i < 10000; i++) {
        c++;
    }

    }

public void decrement() {
    for (int i = 0; i < 5000; i++) {
        c--;
    }
    }

public int value() {
return c;
}

public static void main(String[] args) {

Counter x = new Counter();
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        x.increment();
    }
};

Runnable r2 = new Runnable() {
    @Override
    public void run() {
        x.decrement();
    }
};

Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);     
t1.start();
t2.start();
try {
    Thread.sleep(2000);
} catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
if(!(t1.isAlive() && t2.isAlive()))
System.out.println(x.c);//expected answer 5000
}
}

注意：同步增量/减量方法给出了正确答案。试试自己。

Answer 3

创建多个线程并从这些线程中调用increment(), decrement()和value()。

示例代码如下：

class Counter {
    private int c = 0;

    public void increment() {
        c++;
    }

    public void decrement() {
        c--;
    }

    public int value() {
        return c;
    }

    public static void main(String args[]){
        Counter c = new Counter();
        for ( int i=0; i<3; i++){
            Thread t = new Thread(new MyRunnable(c));
            t.start();
        }
    }
}
class MyRunnable implements Runnable{
    Counter counter;
    public MyRunnable(Counter c){
        counter = c;
    }
    public void run(){
        counter.increment();
        System.out.println("Counter value after increment:"+counter.value()+" from thread:"+  Thread.currentThread().getName());
        counter.decrement();
        System.out.println("Counter value after decrement:"+counter.value()+" from thread:"+  Thread.currentThread().getName());
    }
}

输出:(此输出因每次运行而异）

Counter value after increment:1 from thread:Thread-0
Counter value after decrement:2 from thread:Thread-0
Counter value after increment:2 from thread:Thread-2
Counter value after decrement:1 from thread:Thread-2
Counter value after increment:3 from thread:Thread-1
Counter value after decrement:0 from thread:Thread-1

现在从输出中，您可以了解线程干扰。要解决此问题，您可以使用AtomicInteger。

有关详细信息，请查看以下帖子：

Why is synchronized not working properly?

线程干扰如何在“Counter”示例类中实际发生？

3 个答案: