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

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

Answer 1

问题

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

如果没有同步，没有任何东西可以阻止要访问的线程在同一时间对同一对象调用同一方法。这被称为竞争条件，因为线程正在相互竞争以完成该方法。

输出的第一行打印了2！？这是因为t1写了Count的值，并且在打印它之前就被抢占了。请注意，要抢占线程，它不需要进入Hibernate状态。操作系统仍然这样做。

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

以下是多次运行的最终结果。

不应该想当然地认为总是产生错误的结果，不，有时产生正确的结果，它意味着结果将是不可预测的。

对的误解？

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

这就是所谓的读者作家问题

解决方案

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

synchronized public void run(){}

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

这是由于同步关键字的正确输出。注意：我用200作为循环的结尾。

奖金

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

synchronized(objRef){
   //Method calling
}

objRef是正在同步的对象的引用。

如评论
中推荐的[推荐解决方案]

您应该使用原子整数而不是本机int。使用java.util.concurrent.atomic包。

参考java.util.concurrent.atomic

而不是静态int计数=0；使用静态原子整数计数=新的原子整数（0）；而不是计数；使用count.incrementAndGet（）；

原子整数是固有的同步。

原子整数参考Java文档

Answer 2

您必须使用java.util.concurrent.atomic.原子整数，而不是共享的静态int变量。

Answer 3

之所以发生这种情况，是因为线程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

你应该使用原子整数

并更新您的代码：

static int count=0tostatic AtomicInteger count=new AtomicInteger（）

计数 到<代码>计数。incrementAndGet（）