Java并发 | 16.[基础] synchronized简述

1. synchronized的作用

1.1. 线程安全问题概述

上文提到，「多个线程」「读写」「共享资源」时发生了指令交错，就可能出现线程安全问题。

「互斥锁」可以解决线程安全问题，其核心在于：当存在多个线程操作共享数据时，需要保证同一时刻只有一个线程正在操作该数据，而其他线程必须等该线程处理完毕才能执行。

1.2. 解决线程安全问题

synchronized( Object obj ) 借助锁机制，保证被其包裹的代码块始终是原子性操作（直到拥有锁的线程A执行完这段代码的所有指令，期间其他线程都无法拥有锁，即无法对线程A的执行产生干扰），从而解决线程安全问题。

简单分析以下代码：

static Object obj = new Object(); 
private void function1(){
    synchronized (obj){
        // code here...
    }
}

private void function2(){
    synchronized (obj){
        // code here...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

若开启了两个线程，分别记为t1和t2。由于这两个方法中 synchronized 锁住的是同一个对象，那么：

• [结论] 当 t1 正在执行 function1 时，直到 t1 的这段 synchronized 代码块执行完毕，t2都无法执行 function1 和 function2（t2将被阻塞）；

• [解析] 当t1在执行 function1 时，始终拥有着锁（占用了obj1），t2无法获取锁，既不能执行 function1，也无法执行function2，因而陷入阻塞状态，直到 t1 执行完毕 synchronized 代码块，才会将t2唤醒。

2. synchronized语法

2.1. 标准语法（标准但不常用…）

不常用并不是因为它不正确，而是因为其他的写法可以偷懒 [doge]

static Object obj;	// 对象锁
private void function(){
    synchronized(obj){
        // code here...
    }
}
1
2
3
4
5
6

2.2. 进阶写法（常见写法）

修饰非静态方法

对于非静态方法，以下两种写法是等价的，锁住的对象是「当前对象」，

这意味着「同一对象」中所有被 synchronized 修饰的方法都是互斥的：

public synchronized void baseFunction(){
    // code here...
}
1
2
3

public void baseFunction(){
    synchronized(this){
        // code here...
    }
}
1
2
3
4
5

修饰静态方法

对于静态方法，以下两种写法是等价的，锁住的对象是「类对象」，

这意味着「同一个类」中所有被 synchronized 修饰的方法都是互斥的：

public class Test{
    public synchronized static void baseFunction(){
        // code here...
    }
}
1
2
3
4
5

public class Test{
    public static void baseFunction(){
        synchronized(Test.class){
            // code here...
        }
    }
}
1
2
3
4
5
6
7

特别注意

如果两个synchronized( )锁住的不是同一个对象，那这两段代码块在执行时并不会产生互斥：

// 以下两个代码锁住的不是同一个对象，彼此间的运行并不会产生互斥
public class Test{
    public synchronized void function1(){
        // code here...
    }
    
    public synchronized static void function2(){
        // code here...
    }
}
1
2
3
4
5
6
7
8
9
10

3. synchronized底层原理概述

当一个线程希望执行被 synchronized( Object obj ) 修饰的代码块时，会先尝试获取相应的锁对象obj，并根据是否成功获取该对象而进行不同的操作（直接执行、自旋、锁升级、阻塞等）

3.1. JDK1.6之前（重量级锁）

在jdk1.6之前，synchronized( Object obj ) 的底层就是一个很纯粹的「重量级锁」，一旦编译这段代码，就会从操作系统中申请一个 Monitor 对象并实现重量级锁机制。重量级锁机制的大致流程如下：

当一个线程希望执行被 synchronized( Object obj ) 修饰的代码块时，会先尝试获取相应的锁对象obj：

• 如果能成功获取该对象，则称这个线程 拥有了锁，该线程会对 obj 上锁，此时其他想要执行该代码块的线程都将被阻塞（BLOCKED）；
• 如果不能获取该对象，说明这个 obj 被其他线程上了锁，称该线程 没有抢到锁，它将被阻塞，直到抢到锁的线程执行完毕并将其唤醒。

3.2. JDK1.6以后（偏向锁、轻量级锁和重量级锁）

由于重量级锁需要向操作系统申请一个 Monitor 对象，而且锁机制实现起来相当消耗性能，JDK1.6则根据线程竞争情况来自适应地选择「偏向锁」、「轻量级锁」和「重量级锁」。

本文暂不对这三个锁展开说明

参考资料

[视频] 04.005-上下文切换-synchronized-解决

[视频] 04.006-上下文切换-synchronized-理解

[视频] 04.007-上下文切换-synchronized-理解

[视频] 04.008-上下文切换-synchronized-思考

[视频] 04.010-synchronized-加在方法上

[文章] 从偏向锁是如何升级到重量级锁的