多线程环境中带静态引用/对象的同步块

Question

公共类栏实现可运行{

@Override
public void run() {
    objectLock();
}

public void objectLock() {

    synchronized(this) {
        System.out.println(Thread.currentThread().getName());
        System.out.println("synchronized block " + Thread.currentThread().getName());
        System.out.println("synchronized block " + Thread.currentThread().getName() + " end");
    }
}

public static void main(String[] args) {
    Bar b1 = new Bar();
    Thread t1 = new Thread(b1);
    Thread t2 = new Thread(b1);
    Thread t3 = new Thread(b1);

    Bar b2 = new Bar();
    Thread t4 = new Thread(b2);
    Thread t5 = new Thread(b2);
    Thread t6 = new Thread(b2);

    t1.setName("t1");
    t2.setName("t2");
    t3.setName("t3");
    t4.setName("t4");
    t5.setName("t5");
    t6.setName("t6");


    t1.start();
    t2.start();
    t3.start();

    t4.start();
    t5.start();
    t6.start();

}

}

结果：当T1、t2、T3中的任何线程通过同步块获取锁（例如T1获取）时，t2和T3将处于阻塞状态，但同时允许其他线程T4、T5和T6并发执行。

公共类栏实现可运行{

    @Override
    public void run() {
        objectLock();
    }

    public void objectLock() {

        synchronized(Bar.class) {
            System.out.println(Thread.currentThread().getName());
            System.out.println("synchronized block " + Thread.currentThread().getName());
            System.out.println("synchronized block " + Thread.currentThread().getName() + " end");
        }
    }

    public static void main(String[] args) {
        Bar b1 = new Bar();
        Thread t1 = new Thread(b1);
        Thread t2 = new Thread(b1);
        Thread t3 = new Thread(b1);

        Bar b2 = new Bar();
        Thread t4 = new Thread(b2);
        Thread t5 = new Thread(b2);
        Thread t6 = new Thread(b2);

        t1.setName("t1");
        t2.setName("t2");
        t3.setName("t3");
        t4.setName("t4");
        t5.setName("t5");
        t6.setName("t6");


        t1.start();
        t2.start();
        t3.start();

        t4.start();
        t5.start();
        t6.start();

    }
}

结果：只有Bar类的任何实例的一个线程将获得锁（例如T1获得锁），所有其他线程(T2，T3…T6)将被阻塞，直到T1释放锁。

公共类栏实现可运行{

private static  Integer NUM=new Integer(5);

@Override
public void run() {
    objectLock();
}

public void objectLock() {

    synchronized(NUM) {
        System.out.println(Thread.currentThread().getName());
        System.out.println(NUM++);
        System.out.println("synchronized block " + Thread.currentThread().getName());
        System.out.println("synchronized block " + Thread.currentThread().getName() + " end");
    }
}

public static void main(String[] args) {
    Bar b1 = new Bar();
    Thread t1 = new Thread(b1);
    Thread t2 = new Thread(b1);
    Thread t3 = new Thread(b1);

    Bar b2 = new Bar();
    Thread t4 = new Thread(b2);
    Thread t5 = new Thread(b2);
    Thread t6 = new Thread(b2);

    t1.setName("t1");
    t2.setName("t2");
    t3.setName("t3");
    t4.setName("t4");
    t5.setName("t5");
    t6.setName("t6");


    t1.start();
    t2.start();
    t3.start();

    t4.start();
    t5.start();
    t6.start();

}

synchronized块(synchronized(NUM))中的静态引用NUM是否等同于synchronized(bar.class)？

Answer 1

在synchronized块中使用静态引用/对象会有什么影响（如示例#3)

静态对象在线程之间共享，因此当一个线程获得锁时，所有线程都将阻塞。这意味着如果t1在同步块内，那么t2、t3、…、t6被阻塞。

但是在你提供的代码中有一个诀窍。NUM++这将创建一个新的NUM对象，因为Integer类是不可变的。所以会发生什么，假设t1获得锁并进入同步块。现在，t1执行num++。现在可能会发生很多情况。

null

假设非静态对象不在类条的实例之间共享，因此synchronized块中只能有t1、t2、t3的一个线程。t4、t5、T6也是如此。但是，如果是共享的，则具有与静态对象相同的效果。

synchronized块（synchronized（NUM））中的静态引用NUM是否等同于synchronized（bar.class）？

如果你不改变NUM，就像我在第一个问题的答案中解释的那样