JUC并发编程第七节：synchronized解决线程安全问题

synchronized

介绍：

synchronized：对象锁，保证了临界区内代码的原子性，采用互斥的方式让同一时刻至多只有一个线程能持有对象锁，其它线程获取这个对象锁时会阻塞，保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

互斥和同步都可以采用 synchronized 关键字来完成，区别：

• 互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码
• 同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点

性能：

• 线程安全，性能差
• 线程不安全性能好，假如开发中不会存在多线程安全问题，建议使用线程不安全的设计类

使用锁

锁对象：理论上可以是任意的唯一对象

synchronized 是可重入、不公平的重量级锁

原则上：

• 锁对象建议使用共享资源
• 在实例方法中使用 this 作为锁对象，锁住的 this 正好是共享资源
• 在静态方法中使用类名 .class 字节码作为锁对象，因为静态成员属于类，被所有实例对象共享，所以需要锁住类

加了synchronized关键字临界区中的代码就会变成串行执行。

例子：

@Slf4j(topic = "c.Test17")
public class Test17 {
    public static int count = 0;
    static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 1;i < 5000; i++){
                synchronized (lock){
                    count++;
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 1;i < 5000; i++){
                synchronized (lock){
                    count--;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("count的值是{}",count);
    }

}

输出：

21:10:43.065 c.Test17 [main] - count的值是0

图解：

你可以做这样的类比：

• synchronized(对象) 中的对象，可以想象为一个房间（room），有唯一入口（门）房间只能一次进入一人进行计算，线程 t1，t2 想象成两个人
• 当线程 t1 执行到 synchronized(room) 时就好比 t1 进入了这个房间，并锁住了门拿走了钥匙，在门内执行count++ 代码
• 这时候如果 t2 也运行到了 synchronized(room)时，它发现门被锁住了，只能在门外等待，发生了上下文切换，阻塞住了
• 这中间即使 t1 的 cpu 时间片不幸用完，被踢出了门外（不要错误理解为锁住了对象就能一直执行下去哦），这时门还是锁住的，t1 仍拿着钥匙，t2 线程还在阻塞状态进不来，只有下次轮到 t1 自己再次获得时间片时才能开门进入
• 当 t1 执行完 synchronized{} 块内的代码，这时候才会从 obj 房间出来并解开门上的锁，唤醒 t2 线程把钥匙给他。t2 线程这时才可以进入 obj 房间，锁住了门拿上钥匙，执行它的count--代码

思考

synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。
思考下面的问题:

• 如果把 synchronized(obj) 放在 for 循环的外面，如何理解？-- 原子性
• 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？-- 锁对象
  如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？-- 锁对象

语法

synchronized(锁对象){
	// 访问共享资源的核心代码 临界区
}

同步代码块：

synchronized(锁对象){
	// 访问共享资源的核心代码 临界区
}

实例：

@Slf4j(topic = "c.Test17")
public class Test17 {
    public static int count = 0;
    static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 1;i < 5000; i++){
                synchronized (lock){
                    count++;
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 1;i < 5000; i++){
                synchronized (lock){
                    count--;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("count的值是{}",count);
    }

}

同步方法:

把出现线程安全问题的核心方法锁起来，每次只能一个线程进入访问

synchronized 修饰的方法的不具备继承性，所以子类是线程不安全的，如果子类的方法也被 synchronized 修饰，两个锁对象其实是一把锁，而且是子类对象作为锁

用法：直接给方法加上一个修饰符 synchronized

//同步方法
修饰符 synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}
//同步静态方法
修饰符 static synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}

同步方法底层也是有锁对象的：

• 如果方法是实例方法：同步方法默认用 this 作为的锁对象

public synchronized void test() {

} 
//等价于
public void test() {
    synchronized(this) {}
}

• 如果方法是静态方法：同步方法默认用类名 .class 作为的锁对象

class Test{
	public synchronized static void test() {}
}
//等价于
class Test{
    public void test() {
        synchronized(Test.class) {}
	}
}