Synchronized同步方法和同步代码块

synchronized关键字可以使用在方法上或者锁定一段代码块。那么同步方法和同步代码块的区别是什么呢？我们用代码来研究一下。

准备工作

首先我们准备一个测试类ClassLock。

public class ClassLock {

    public static void main(String[] args) {
        ClassLock classLock1 = new ClassLock();
        ClassLock classLock2 = new ClassLock();

        new Thread(() -> classLock1.lock()).start();
        new Thread(() -> classLock2.lock()).start();
    }

    private void lock() {
        int i = 0;
        do {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this + " is locked " + i);
        } while (i++ < 10);
    }
}

这里的代码是没有加上任何同步方式的，此时的结果为：

多线程.对象锁.ClassLock@4433de98 is locked 0
多线程.对象锁.ClassLock@38f0356c is locked 0
多线程.对象锁.ClassLock@4433de98 is locked 1
多线程.对象锁.ClassLock@38f0356c is locked 1
多线程.对象锁.ClassLock@4433de98 is locked 2
多线程.对象锁.ClassLock@38f0356c is locked 2
...

两个线程同步操作，没有任何竞争。意料之中。接下来我们看synchronized在方法和代码块上的不同表现。

同步方法

给lock()方法加上synchronized关键字后，再次运行代码，发现和无锁的运行结果一致。

private synchronized void lock() {
        int i = 0;
        do {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this + " is locked " + i);
        } while (i++ < 10);
    }

多线程.对象锁.ClassLock@4433de98 is locked 0
多线程.对象锁.ClassLock@38f0356c is locked 0
多线程.对象锁.ClassLock@4433de98 is locked 1
多线程.对象锁.ClassLock@38f0356c is locked 1
多线程.对象锁.ClassLock@4433de98 is locked 2
多线程.对象锁.ClassLock@38f0356c is locked 2
...

还是两个线程同步打印，这是因为同步方法锁的是方法的this，也就是执行这个方法的对象。因为是起了两个对象作为两个线程，所以不存在竞争行为。

为了验证我们的猜想，将两个线程改为都是执行对象1的lock方法，此时的结果为：

多线程.对象锁.ClassLock@5ec1d90c is locked 0
多线程.对象锁.ClassLock@5ec1d90c is locked 1
...
多线程.对象锁.ClassLock@5ec1d90c is locked 10
多线程.对象锁.ClassLock@5ec1d90c is locked 0
多线程.对象锁.ClassLock@5ec1d90c is locked 1
...
多线程.对象锁.ClassLock@5ec1d90c is locked 10

结果表明，是某个先抢占到资源的线程打印完10次之后，另一个等待线程再获取资源打印。

同步代码块

与同步方法不同的是，同步代码块是显式声明资源。

private void lock() {
        synchronized (this.getClass()) {
            int i = 0;
            do {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(this + " is locked " + i);
            } while (i++ < 10);
        }
    }

这里synchronize的括号里是一个对象。

• 当括号里是this时，锁的是当前调用方法的对象
• 当括号里是一个Class对象时，锁的是这个类，也就是同一个类的实例，任意时刻只会有一个线程能获得资源

上述方法调用结果：

多线程.对象锁.ClassLock@4d47348f is locked 0
多线程.对象锁.ClassLock@4d47348f is locked 1
...
多线程.对象锁.ClassLock@4d47348f is locked 10
多线程.对象锁.ClassLock@4e7eaa82 is locked 0
多线程.对象锁.ClassLock@4e7eaa82 is locked 1
...
多线程.对象锁.ClassLock@4e7eaa82 is locked 10

结论

对象锁: synchronized(object) 锁住的是对象,每个对象自己拥有一个锁
类锁: synchronized(Class) 锁住的是类，也就是同一个类的实例，任意时刻只会有一个线程能获得资源