java synchronized关键字是并发编程最常用的工具，也是最重要的工具之一。今天来探究下其含义
写两个类，两段不同的临界区代码进行测试。
有以下4种测试方案，每种方案对应4种不同的锁类型：对象锁: synchronized(this)，本类锁: synchronized(Me.class)，父类锁: synchronized(Parent.class)，自定义锁对象
1. 同一个对象，在不同线程中运行
2. 同一个类的不同对象，在不同线程中运行
3. 不同类（有共同的父类）的不同对象，在不同线程中运行
4. 不同类（没有共同的父类）的不同对象，在不同线程中运行
测试结果：
用对象锁，只有1可以互斥访问临界区；
用本类锁，则1和2可以互斥访问临界区；
用共同父类的锁，全部都可以互斥访问临界区。（注意，使用第4种测试方案时，两个对象已经没有共同的父类了，因此这个所谓共同父类的锁，其实是一个第3者，与这两个类没有直接关系，类似于自定义的锁对象，只不过这个自定的锁对象不是普通的对象，而是一个Class对象）
用自定义的锁对象，全部都可以互斥访问临界区。
/** * synchronized关键字测试 * * @author zhangxz * @date 2019-11-18 11:07 */ public class SynchronizedTest { private static final Sync sync = new Sync(); public static void main(String[] args) throws InterruptedException { ThreadA threadA1 = new ThreadA(); ThreadA threadA2 = new ThreadA(); ThreadB threadB = new ThreadB(); // testOneRunnable(threadA1); // testTwoRunnable(threadA1, threadA2); testTwoRunnable(threadA1, threadB); } static class Sync{} //使用一个runnable对象，在两个不同线程调用 static void testOneRunnable(Runnable runnable) { Thread thread1 = new Thread(runnable); Thread thread2 = new Thread(runnable); thread1.start(); thread2.start(); } //使用两个runnable对象，在两个不同线程调用 static void testTwoRunnable(Runnable runnable1, Runnable runnable2) { Thread thread1 = new Thread(runnable1); Thread thread2 = new Thread(runnable2); thread1.start(); thread2.start(); } static class ABParent { } static class ThreadA/* extends ABParent */implements Runnable { @Override public void run() { // synchronized (this) { // synchronized (ThreadA.class) { // synchronized (ABParent.class) { synchronized (sync) { try { Thread.sleep(10); System.out.println("process in thread a " + Thread.currentThread().getName()); Thread.sleep(10); System.out.println("process in thread a " + Thread.currentThread().getName()); Thread.sleep(10); System.out.println("process in thread a " + Thread.currentThread().getName()); Thread.sleep(10); } catch (InterruptedException e1) { e1.printStackTrace(); } } } } static class ThreadB /*extends ABParent*/ implements Runnable { @Override public void run() { // synchronized (this) { // synchronized (ThreadB.class) { // synchronized (ABParent.class) { synchronized (sync) { try { Thread.sleep(10); System.out.println("process in thread b " + Thread.currentThread().getName()); Thread.sleep(10); System.out.println("process in thread b " + Thread.currentThread().getName()); Thread.sleep(10); System.out.println("process in thread b " + Thread.currentThread().getName()); Thread.sleep(10); } catch (InterruptedException e1) { e1.printStackTrace(); } } } } }
另外的测试
1. 把其中一个类的synchronized去除，即一个是临界区，另外一个不是。然后对其测试，发现无论临界区用的哪种锁，两者都无法实现互斥访问。
2. 把两个类的锁对象改为不同的锁，则两个synchronized代码块因为持有不同的锁，无法构成临界区，因此也无法实现互斥访问。
3. 测试同一个对象的不同synchronized方法，如下代码。测试结果：同一个对象的不同synchronized方法构成同一个临界区，可以互斥访问。
static void testDifferentMethodsInOneObject(TestA testA) { Runnable runnable1 = () -> { try { testA.MethodA(); testA.MethodB(); } catch (InterruptedException e) { e.printStackTrace(); } }; Runnable runnable2 = () -> { try { testA.MethodB(); testA.MethodA(); } catch (InterruptedException e) { e.printStackTrace(); } }; Thread thread1 = new Thread(runnable1); Thread thread2 = new Thread(runnable2); thread1.start(); thread2.start(); } static class TestA { public synchronized void MethodA() throws InterruptedException { Thread.sleep(10); System.out.println("process in method a " + Thread.currentThread().getName()); Thread.sleep(10); System.out.println("process in method a " + Thread.currentThread().getName()); Thread.sleep(10); System.out.println("process in method a " + Thread.currentThread().getName()); Thread.sleep(10); } public synchronized void MethodB() throws InterruptedException { Thread.sleep(10); System.out.println("process in method b " + Thread.currentThread().getName()); Thread.sleep(10); System.out.println("process in method b " + Thread.currentThread().getName()); Thread.sleep(10); System.out.println("process in method b " + Thread.currentThread().getName()); Thread.sleep(10); } }
synchronized 使用的最终结论：
1. 临界区和非临界区是无法实现互斥访问的。
2. 同一个对象的临界区(即使是不同的synchronized代码块，也只能构成同一个临界区，因为synchronized锁的最小粒度是对象锁)，只要加锁就可以互斥访问。
3. 同一个类的不同对象/不同类的不同对象，两者的synchronized代码块虽然不再同一个地方，但是只要锁的粒度足够大，大到覆盖了两个代码块，则两个代码块就构成了一个临界区，就能实现互斥访问。
4. 使用自定义的公共变量作为锁对象，只要规定进入代码块必须获得同一把锁，则可以对于任何地方的临界区实现互斥访问。
附加测试：
当同一个对象，有两个方法，一个为static，一个普通的，然后两个方法都使用了synchronized，那么这两个方法可以实现互斥访问吗？
答案是否定的，因为两个方法持有的锁是不同的两把锁，一个为类锁，一个为对象锁，因此两者不能构成临界区。（我一开始的思维是，两把锁，一个锁比较大，另外一个锁比较小，那么大的锁是覆盖了小粒度的锁的，但实验证明这个想当然是错误的。）代码如下：
/** * synchronized测试类2 * * @author zhangxz * @date 2019-11-18 21:43 */ public class SynchronizedTest2 { public static void main(String[] args) { TestA testA = new TestA(); new Thread(() -> { testA.a(); }).start(); new Thread(() -> { testA.b(); }).start(); } static class TestA { static synchronized void a() { System.out.println("i am method a."); Thread.yield(); System.out.println("i am method a."); Thread.yield(); System.out.println("i am method a."); } synchronized void b() { System.out.println("i am method b."); Thread.yield(); System.out.println("i am method b."); Thread.yield(); System.out.println("i am method b."); } } }
上面测试用到了 Thread类的 yield方法，这个方法的效果是当前线程做出cpu时间片的让步，在当前线程执行后续步骤之前，让其他线程有机会得到cpu的执行时间。在测试多线程问题中比较常用。
参考链接：