Java多线程跳过循环并给出错误的结果[重复]

Question

Java 多线程跳过循环并给出错误结果

package Threading;

class DemoThread extends Thread{   //Thread Class   
    static int count=0;   // variable incremented by both the threads

    public DemoThread(String name) {
        // TODO Auto-generated constructor stub
        super(name);
    }

    public void run() { 
        for(int i=0;i<100000;i++) {
            count++;
            System.out.println(Thread.currentThread()+"Count"+count);  // print thread operating on count variable
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }           
        }       
    }   
}


public class MyThreadClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub      
        DemoThread t1=new DemoThread("T1");
        DemoThread t2=new DemoThread("T2");
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();  //allowing both the threads to complee before main thread
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("Main Thread ends"+DemoThread.count);  //final value of count        
    }
}

count 的最终值应该是 199998，但它没有给出预期的结果。 为什么线程缺少循环???

Answer 1

这是因为线程 T1 和 T2 将同时更新 count（并发）：

Thread[T1,5,main]Count10
Thread[T2,5,main]Count10
Thread[T1,5,main]Count12
Thread[T2,5,main]Count12
Thread[T2,5,main]Count14
Thread[T1,5,main]Count14
Thread[T1,5,main]Count15
Thread[T2,5,main]Count16

你应该使用AtomicInteger

并更新您的代码：

static int count=0; 到 static AtomicInteger count= new AtomicInteger();

count++; 到 count.incrementAndGet();

Answer 2

您必须使用 java.util.concurrent.atomic.AtomicInteger 而不是共享静态 int 变量。

Answer 3

问题

在 Java 中，多线程为您的程序引入了异步行为，您必须在需要时强制执行同步。

没有同步，没有什么能阻止线程同时在同一个对象上调用同一个方法。这称为竞争条件，因为线程相互竞争以完成该方法。

程序的输出：

输出的第一行打印了 2!?这是因为 t1 写入了 count 的值并在打印之前被抢占。请注意，要抢占一个线程，它不需要进入睡眠状态。操作系统始终这样做。

如果您注意到第 1^st 行和第 4^th 行，您可以看到不一致之处。这种不一致在大型程序中变得不可预测。

这是多次运行的最终结果。

不应认为总是产生错误的结果。不，有时会产生正确的结果。这意味着结果将是不可预测的。

---

误会了吗？

线程跳过循环。！？不，线程没有跳过循环。不同的线程访问了相同的值，但在它可以写入自己的值之前，其他线程写入了该值并继续。结果下次访问该值时，它选择了错误的值。

这被称为Reader Writer Problem

---

解决方案

在您的程序中，t1 和 t2 正在使用不同的值访问您的 count 变量。为了防止其他线程在其他线程完成之前调用 run()，我们在方法之前添加了一个 synchronized 关键字。

synchronized public void run(){}

synchronized 关键字保护状态免受竞争条件的影响。一次，一个线程进入同步方法，直到前一个线程退出该方法，其他线程才被允许使用该方法。

由于 synchronized 关键字，这是正确的输出。 注意：我使用 200 作为循环结束。

---

奖金

如果您正在使用将共享数据作为输入的专有方法。您可以使用同步块

synchronized(objRef){
   //Method calling
}

objRef 是被同步对象的引用。

---

在 cmets 中推荐
[推荐解决方案]

您应该使用 AtomicInteger 而不是原生 int。使用java.util.concurrent.atomic 包。

Reference to java.util.concurrent.atomic

用static AtomicInteger count = new AtomicInteger(0);代替static int count = 0;，用count.incrementAndGet();代替count++;

AtomicInteger 本质上是同步的。

Atomic Integer Reference Java Docs

---