Java线程通过两个线程和一个静态变量连接 公共类TestThread2{ 静态整数计数=0； 公共静态void main（字符串[]args）{ 线程t=新线程（新的可运行线程（）{ 公开募捐 { 对于（int i=1；i

您没有同步变量。如果您没有同步变量，请使用。

而不是。

静态int count。如果您没有同步变量，请使用。

i++

而不是原子。它有效地：

public class TestThread2 {

    static int count = 0;
    public static void main(String[] args) {

        Thread t = new Thread(new Runnable(){
            public void run()
            {
                for (int i=1; i<=100000; i++) {
                    count++;
                }           
            }
        });
        Thread t1 = new Thread(new Runnable(){
            public void run()
            {
                for (int i=1; i<=100000; i++) {
                    count++;
                }           
            }
        });
        t.start();
        t1.start();

        try{
            t.join();
            t1.join();
        }
        catch(InterruptedException e){
            e.printStackTrace();
        }

        System.out.println(count);
    }
}

如果两个线程同时尝试执行此操作，则来自不同线程的读写可能会交错，这意味着每个线程中的值不会严格递增

此外，不能保证一个线程增加的值对另一个线程可见

不要使用

int

，而是使用

AtomicInteger

，和

addAndGet

AtomicInteger

保证增量的原子性和线程之间值的可见性

int j = i;
i = j + 1;

---

---

请注意，中描述了与您的示例非常类似的内容。

i++

不是原子的。它实际上是：

public class TestThread2 {

    static int count = 0;
    public static void main(String[] args) {

        Thread t = new Thread(new Runnable(){
            public void run()
            {
                for (int i=1; i<=100000; i++) {
                    count++;
                }           
            }
        });
        Thread t1 = new Thread(new Runnable(){
            public void run()
            {
                for (int i=1; i<=100000; i++) {
                    count++;
                }           
            }
        });
        t.start();
        t1.start();

        try{
            t.join();
            t1.join();
        }
        catch(InterruptedException e){
            e.printStackTrace();
        }

        System.out.println(count);
    }
}

如果两个线程同时尝试执行此操作，则来自不同线程的读写可能会交错，这意味着每个线程中的值不会严格递增

此外，不能保证一个线程增加的值对另一个线程可见

不要使用

int

，而是使用

AtomicInteger

，和

addAndGet

AtomicInteger

保证增量的原子性和线程之间值的可见性

int j = i;
i = j + 1;

---

---

请注意，与您的示例非常相似的内容在中进行了描述。

是

join（）上的主线程块

。但是主线程不写入变量

count

，因此不管主线程在做什么。您有两个线程，

t

和

t1

，它们在没有任何同步的情况下读取和写入同一变量

count

，并且确实会导致不稳定的结果。

是的主线程阻塞

加入

。但是主线程不会写入变量

count

，因此不管主线程在做什么。您有两个线程，

t

和

t1

，它们在没有任何同步的情况下读取和写入相同的变量

count

，并且确实会导致不稳定的结果。

i++

不是原子的。这是是Java concurrency 101；在实践中阅读Java concurrency。通常，您会在一个从2开始的线程上调用

await（）

，当每个线程完成（最后一个块）时，它是

countDown（）

没有太多的关联，但要得到相同的答案，您可以设置关联，并且只使用一个核心。然后您将始终得到相同的答案。

i++

不是原子的。这是Java并发101；在实践中阅读Java并发。通常，您会调用从2开始的

wait（）

，并且是

countDown（）

当每个线程完成（最终阻塞）时，没有太多关联，但为了得到相同的答案，您可以设置关联，并且只使用一个核心。然后您将始终得到相同的答案。