线程干扰在“计数器”示例类中实际发生的方式

我正在尝试学习线程干扰的概念，并在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 类的代码示例来演示线程干扰的实际发生方式吗？

比起

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

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

当 A 和

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

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

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

在这种情况下很少观察到，因为它是一个小程序，没有发生太多事情。如果对螺纹进行多次递增和递减，则螺纹干涉将更容易观察到。

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
}
}

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

创建多个线程并从这些线程调用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。

查看下面的帖子以获取更多详细信息：

为什么同步无法正常工作？

相关内容

最新更新

热门标签：