NO.26 synchronized关键字画像：正确打开方式

synchronized在非静态上下文中的应用解析

首先，我们先看一个代码例子，然后再详细分析一下为什么会这样。

代码1：

//模拟一个线程，探究在编程实践中
//synchronized是如何持有对象锁
//如何实现同步控制的
public class DemoA extends Thread{
    private String msg;

    public DemoA(String str){
        this.msg = str;
    }

    public synchronized void print(String str){
        while(true){
            try {
                //模拟一个耗时操作，调用sleep函数
                //会释放占用的CPU，但是不会释放对象锁
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(str);
        }
    }

    //覆写Thread的run方法
    public void run(){
        print(msg);
    }
}

代码2：

public class DemoB extends Thread{
    private DemoA demoA;

    public DemoB(DemoA a){
        demoA = a;
    }

    //覆写Thread方法
    //委托DemoA对象，调用操作
    public void run(){
        demoA.print("B");
    }
}

代码3：

//非静态上下文
//synchronized修饰符在同步控制中的作用
public class NoStaticSyncTest {
    public static void main(String[] args){
    DemoA demoA1 = new DemoA("A1");
    demoA1.start();  //线程A1

    DemoB demoB = new DemoB(demoA1);
    demoB.start();   //线程B

    DemoA demoA2 = new DemoA("A2");
    demoA2.start();  //线程A2
    }
}

老铁们可以先想一想该程序的运行结果，然后再往下看。

线程A1通过对象demoA1启动，并调用了被synchronized修饰的print成员函数，按照我们上文（NO.25 synchronized关键字画像：开胃菜）所提到的，线程要进入并执行该成员函数，需要先获取demoA1所关联锁，由于该锁当前并没有被任何线程使用，所以线程A1顺利的获取了demoA1的所关联的lock，并开始执行print函数。

紧接着，线程B通过对象demoB启动，并通过传入的demoA1对象引用，调用了被synchronized修饰的print成员函数；同理，要执行该函数，需要获取调用该函数的对象demoA1所持有的锁，由于该锁已经被线程A1执行过程所持有，为此线程B只能等待线程A1执行完成释放demoA1所持有的锁以后，才能得到执行的机会；但是，print函数是一个“死”循环，为此线程B会一直被阻塞着，直到JVM退出而终止。

最后，线程A2通过对象demoA2启动，并调用了被synchronized修饰的print成员函数；同理，线程要进入并执行该成员函数，需要先获取demoA2所关联锁，由于该锁（由于每个对象都会有一个与之关联的lock，即使属于同一类型的对象所持有的锁也是不同的，因此该锁不同于demoA1所关联的锁）当前并没有被任何线程使用，所以线程A2顺利的获取了demoA2的所关联的lock，并开始执行print函数。

通过以上分析，线程A1与线程A2会交替执行，线程B会因为一直不能获取到demoA1所关联的锁而被永久阻塞。因此，该函数的输出结果，“可能”会是这样：

A1
A2
A1
A2
A1
A2

synchronized在静态上下文中的应用解析

同样地，我们先看一个代码例子，然后再详细分析一下为什么会这样。

代码4：

public class DemoC implements Runnable{
    private String msg;

    public DemoC(String str){
        msg = str;
    }

    public synchronized void print1(String str){
        while(true){
            try {
                //模拟一个耗时操作，调用sleep函数
                //会释放占用的CPU，但是不会释放对象锁
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(str);
        }
    }

    public synchronized static void print2(String str){
        while(true){
            try {
                //模拟一个耗时操作，调用sleep函数
                //会释放占用的CPU，但是不会释放对象锁
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(str);
        }
    }

    public void run(){
        print1(msg);
    }
}

代码5：

public class StaticSyncTest {
    public static void main(String[] args){
    DemoC demoC1 = new DemoC("C1");
    Thread c1 = new Thread(demoC1);
    c1.start();

    demoC1.print2("C2");
    }
}

老铁们可以先想一想该程序的运行结果，接着，我们再一起往下看。

该程序首先定义了一个对象引用demoC1，然后启动线程c1，该线程会执行被synchronized修饰的print1函数，进入print1函数前，会首先判断是否持有对象引用demoC1的锁，由于该锁尚未被其他线程所占用，为此该线程会被执行；接着demoC1会调用print2函数，该函数同时被synchronized与static关键字修饰，按照我们上文所提及的方法，要进入该函数，需要持有DemoC.class对象所关联lock，由于该对象尚未被其他线程所持有，为此该函数也将被执行。

通过以上分析，线程c1与demoC1.print2都会被执行。因此，该函数的输出结果，“可能”会是这样：

结果：

C1
C2
C1
C2
C2
C1
C2

合理利用synchronized实现线程同步

通过以上分析，我们就基本掌握了synchronized在非静态上下文与静态上下文中是如何在线程间同步发挥作用的。

推而广之，我们一般有三种利用synchronized方法实现线程同步的方法：

• 第一种：修饰方法

代码6：

//synchronized修饰成员函数
//该函数能被执行，则意味则持有了调用
//该函数的对象引用所持有的lock
//多个函数如果存在同步关系，则可以在这
//些函数前面都增加synchronize修饰
public synchronized void subroutine1(){

}

• 第二种：修饰一般对象或this对象

代码7：

private DemoA demoA = new DemoA("A");
//多个函数如果存在同步关系，则可以
//用synchronize修饰demoA对象
public synchronized void subroutine2(){
    synchronized(demoA){

    }
}

//多个函数如果存在同步关系，则可以
//用synchronize修饰this对象
public synchronized void subroutine1(){
    synchronized(this){

    }
}

• 第三种，修饰轻量级对象

代码8：

private byte[] lock = new byte[1];
//多个函数如果存在同步关系，则可以
//用synchronize修饰lock对象
//lock是一个轻量级对象
public void subroutine2(){
    synchronized(lock){

    }
}

为了适应高并发性能以及快速响应的要求，synchronized不同的写法对程序响应的快慢和对CPU等资源利用率是不同的；对比以上方式，从程序运行性能与执行效率来看，从高到低依次排序为：第三种方式 > 第二种方式 > 第一种方式。

划重点：

1. 关键字synchronized锁定的是对象，而不是函数或代码。函数或代码区块被声明或修饰为synchronized，并非意味着它同一时刻只能由一个线程执行。
2. 因为锁定的对象不一样，加锁与解锁都需要此对象资源，为此锁定的对象资源越小，性能开销就越小，采用byte作为锁对象最为经济。
   
   1. 当synchronized用于修饰对象引用时，则取得的lock将被交给该引用所指向的对象。
   2. 当调用一个synchronized static 函数时，获得的lock将与定义该函数的class相关联，而不是与调用函数的那个对象相关联。当synchronized修饰的是A.class时，获得的lock也是与上述相同，即与class相关联。

转载自公众号：代码荣耀