为什么同步块给出错误的答案？

Question

我正在努力学习同步。根据我所了解的，下面的代码应该给出8000作为最终结果，但是我得到了一个随机的结果，如下所示；

import java.time.LocalDateTime;

public class A implements Runnable {
    String name;
    static Integer j=0;
    A(String name){
        this.name=name;
    }
    @Override
    public synchronized void  run() {
        for(int i=1;i<=1000;i++){
            synchronized(this){
            A.j++;
            }
        }
        System.out.println(j);
    }

package threads;

public class MainClass {
public static void main(String args[]){
    Thread t1=new Thread(new A("i am thread A "));
    Thread t2=new Thread(new A("i am thread B "));
    Thread t3=new Thread(new A("i am thread C "));
    Thread t4=new Thread(new A("i am thread D "));
    Thread t5=new Thread(new A("i am thread E "));
    Thread t6=new Thread(new A("i am thread F "));
    Thread t7=new Thread(new A("i am thread G "));
    Thread t8=new Thread(new A("i am thread H "));
    t1.setPriority(Thread.MAX_PRIORITY);
    t8.setPriority(Thread.MIN_PRIORITY);
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
    t6.start();
    t7.start();
    t8.start();
    try {
        t1.join();
        t2.join();
        t3.join();
        t4.join();
        t5.join();
        t6.join();
        t7.join();
        t8.join();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }


}
}

还是得到1293 2214 1403 3214 4214 5214 6224 7037这样的输出有没有人能给我解释一下如何实现同步，这里出了什么问题？

Answer 1

代码中有几个问题。

> < li>

问题1:在< code>synchronized(..)不在所有线程实例之间共享

第2期:< code > system . out . println(j)；行应该在< code>t8.join()之后结束；否则，您将获得8倍的输出。

修正代码

public class A implements Runnable {

    String name;
    static Integer j = 0;

    static Object lockObject = new Object();

    A(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 1000; i++) {
            synchronized (lockObject) {
                A.j++;
            }
        }
    }


    public static void main(String args[]) {
        Thread t1 = new Thread(new A("i am thread A "));
        Thread t2 = new Thread(new A("i am thread B "));
        Thread t3 = new Thread(new A("i am thread C "));
        Thread t4 = new Thread(new A("i am thread D "));
        Thread t5 = new Thread(new A("i am thread E "));
        Thread t6 = new Thread(new A("i am thread F "));
        Thread t7 = new Thread(new A("i am thread G "));
        Thread t8 = new Thread(new A("i am thread H "));
        t1.setPriority(Thread.MAX_PRIORITY);
        t8.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        t7.start();
        t8.start();
        try {
            t1.join();
            t2.join();
            t3.join();
            t4.join();
            t5.join();
            t6.join();
            t7.join();
            t8.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(A.j);

    }
}

Answer 2

这将解决问题。您必须使用共享锁对所有线程进行< code>synchronize，因为您正在递增一个静态字段。否则，每个对象将拥有自己的锁，并并行递增静态字段，从而导致竞争情况。这就是为什么你没有得到正确的值，在这个例子中是8000。

package bookmarks;

public class A implements Runnable {
    String name;
    static Integer j = 0;
    private static Object lock = new Object();

    A(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 1000; i++) {
            synchronized (lock) {
                A.j++;
            }
        }
        System.out.println(j);

    }

}

Answer 3

认为synchronized表示“关键部分”，并且在同步块运行时不会运行其他线程，这是一个常见的错误。但是，同步块只对锁定在同一锁上的其他同步块具有独占性。

你得到的答案(“使用普通锁”)是对的，但没有真正告诉你为什么。另一个常见的错误是认为< code>synchronized是保护代码，而实际上你应该考虑它保护数据。任何共享的可变数据都应该由一个锁来保护，并且只有一个锁，你应该确切地知道那个锁是什么。(您的锁定方案越复杂，您就越不可能知道什么锁保护什么数据。)因此，您应该始终考虑“数据X由锁L保护”，然后确保无论何时访问(读或写)该数据时都获得锁L。