synchronized 作为悲观锁，锁住了什么？
synchronized 作为悲观锁，锁住了什么？
继续来认识 「synchronized」，上篇文章用不用 synchronized 的区别？我们了解了 「synchronized」 是在多线程并发竞争同一资源的时候使用，这一篇我们来了解，synchronized 作为悲观锁，锁住了什么？
锁实例对象
上篇文章我们就有锁实例对象的代码样例，只是当时没有细说这个概念。我们再写一个代码来测试一下。代码逻辑是这样的：我们写 2 个 「synchronized」 实例方法，让 5 个线程随机执行 2 个方法。代码如下：
只有一个实例对象的情况：
public class SynchronizedTest {
public static void main(String[] args) {
SynchronizedTest synchronizedTest = new SynchronizedTest();
for (int i = 0; i < 5; i++) {
int thisi = i;
Thread thread = new Thread(() -> {
if (thisi % 2 == 0) {
synchronizedTest.testSynchronizedMethod1();
} else {
synchronizedTest.testSynchronizedMethod2();
}
});
thread.start();
}
}
public synchronized void testSynchronizedMethod1() {
System.out.printf("%s-testSynchronizedMethod1-start-count=%s\n", Thread.currentThread().getName(), count);
count ++;
System.out.printf("%s-testSynchronizedMethod1-end-count=%s\n", Thread.currentThread().getName(), count);
}
public synchronized void testSynchronizedMethod2() {
System.out.printf("%s-testSynchronizedMethod2-start-count=%s\n", Thread.currentThread().getName(), count);
count ++;
System.out.printf("%s-testSynchronizedMethod2-end-count=%s\n", Thread.currentThread().getName(), count);
}
}
运行结果：
这份代码里面有 5 个线程竞争一个 synchronizedTest 资源，所以只能串行跑，我们这里用了 2 个方法，为了让大家更清楚的明白锁的是对象，而不是锁对象里面的某个方法。如果是锁方法，那么线程「Thread-0」调用testSynchronizedMethod1方法和线程「Thread-1」调用testSynchronizedMethod2方法就不会串行执行，会并发执行；但是结果是串行执行，也就验证了是锁 synchronizedTest 对象而不是方法。通过 count 结果，更加清晰的了解，方法是串行执行的。
每个线程一个实例对象的情况：
public class SynchronizedTest {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
SynchronizedTest synchronizedTest = new SynchronizedTest();
int thisi = i;
Thread thread = new Thread(() -> {
if (thisi % 2 == 0) {
synchronizedTest.testSynchronizedMethod1();
} else {
synchronizedTest.testSynchronizedMethod2();
}
});
thread.start();
}
}
public synchronized void testSynchronizedMethod1() {
System.out.printf("%s-testSynchronizedMethod1-start-count=%s\n", Thread.currentThread().getName(), count);
count ++;
System.out.printf("%s-testSynchronizedMethod1-end-count=%s\n", Thread.currentThread().getName(), count);
}
public synchronized void testSynchronizedMethod2() {
System.out.printf("%s-testSynchronizedMethod2-start-count=%s\n", Thread.currentThread().getName(), count);
count ++;
System.out.printf("%s-testSynchronizedMethod2-end-count=%s\n", Thread.currentThread().getName(), count);
}
}
这份代码是每个线程有独立的对象，线程之间没有竞争，所以互不影响，count 也都是线程独立的，所以 end 结果都是 1。这个例子为了和下面的锁类的 Class 对象做对比，先记住锁实例对象的情况，只要线程之间锁的不是同一个实例对象，线程之间就没有竞争。
锁类的 Class 对象
我们将本来实例方法改成 static 静态方法，这份代码 IDE 会提示异常，咱先忽略异常，可以执行成功。
public class SynchronizedTest {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
SynchronizedTest synchronizedTest = new SynchronizedTest();
Thread thread = new Thread(() -> {
synchronizedTest.testSynchronizedStaticMethod();
});
thread.start();
}
}
public static synchronized void testSynchronizedStaticMethod() {
System.out.println("testSynchronizedStaticMethod-start-" + Thread.currentThread().getName());
System.out.println("testSynchronizedStaticMethod-end-" + Thread.currentThread().getName());
}
}
代码结果：
我们可以看出，5 个线程执行到testSynchronizedStaticMethod方法都是串行执行，这和上面的例子有点差别，上面例子 5 个实例对象的情况下是互不影响的。所以可以看出，加上 static 不是锁实例对象，而是「锁 Class 对象」。
总结
这一篇我们讲了 「synchronized」 修饰方法时的 2 种锁机制：锁实例对象和锁类的 Class 对象。从锁的「粗粒度」来对比，锁类 Class 对象的粒度大于锁实例对象。
同步方法是 「synchronized」 最简单的用法，接下来一篇会讲 「synchronized」 的代码块用法，代码块用法把锁粒度再降一个档次，期待你到时阅读。
腾讯云开发者
