JUC（六）：synchronized

1. 语法

synchronized(对象) // 线程1， 线程2(blocked)
{
    
    
    临界区
}

2. * 应用之互斥

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

阻塞式的解决方案：synchronized，Lock
非阻塞式的解决方案：原子变量

本次课使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

注意

虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成，但它们还是有区别的：

互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码

同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点

3. 解决共享问题

static int counter = 0;
static final Object room = new Object();
public static void main(String[] args) throws InterruptedException {
    
    
    Thread t1 = new Thread(() -> {
    
    
        for (int i = 0; i < 5000; i++) {
    
    
            synchronized (room) {
    
    
                counter++;
            }
        }
    }, "t1");
    Thread t2 = new Thread(() -> {
    
    
        for (int i = 0; i < 5000; i++) {
    
    
            synchronized (room) {
    
    
                counter--;
            }
        }
    }, "t2");
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    log.debug("{}",counter);
}

4. 类比理解

在这里插入图片描述

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 没有加会怎么样？如何理解？-- 锁对象

5. 面向对象改进

把需要保护的共享变量放入一个类

class Room {
    
    
    int value = 0;
    public void increment() {
    
    
        synchronized (this) {
    
    
            value++;
        }
    }
    public void decrement() {
    
    
        synchronized (this) {
    
    
            value--;
        }
    }
    public int get() {
    
    
        synchronized (this) {
    
    
            return value;
        }
    }
}

@Slf4j
public class Test1 {
    
    

    public static void main(String[] args) throws InterruptedException {
    
    
        Room room = new Room();
        Thread t1 = new Thread(() -> {
    
    
            for (int j = 0; j < 5000; j++) {
    
    
                room.increment();
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
    
    
            for (int j = 0; j < 5000; j++) {
    
    
                room.decrement();
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("count: {}" , room.get());
    }
}

6. 方法上的 synchronized

class Test{
    
    
    public synchronized void test() {
    
    

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

        }
    }
}

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

        }
    }
}

7. 不加 synchronized 的方法

不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的）

8. 所谓的“线程八锁”

其实就是考察 synchronized 锁住的是哪个对象

情况1：12 或 21

@Slf4j(topic = "c.Number")
class Number{
    
    
    public synchronized void a() {
    
    
        log.debug("1");
    }
    public synchronized void b() {
    
    
        log.debug("2");
    }
}
public static void main(String[] args) {
    
    
    Number n1 = new Number();
    new Thread(()->{
    
     n1.a(); }).start();
    new Thread(()->{
    
     n1.b(); }).start();
}

情况2：1s后12，或 2 1s后 1

@Slf4j(topic = "c.Number")
class Number{
    
    
    public synchronized void a() {
    
    
        TimeUnit.SECONDS.sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
    
    
        log.debug("2");
    }
}
public static void main(String[] args) {
    
    
    Number n1 = new Number();
    new Thread(()->{
    
     n1.a(); }).start();
    new Thread(()->{
    
     n1.b(); }).start();
}

情况3：3 1s 12 或 23 1s 1 或 32 1s 1

@Slf4j(topic = "c.Number")
class Number{
    
    
    public synchronized void a() {
    
    
        TimeUnit.SECONDS.sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
    
    
        log.debug("2");
    }
    public void c() {
    
    
        log.debug("3");
    }
}
public static void main(String[] args) {
    
    
    Number n1 = new Number();
    new Thread(()->{
    
     n1.a(); }).start();
    new Thread(()->{
    
     n1.b(); }).start();
    new Thread(()->{
    
     n1.c(); }).start();
}

情况4：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
    
    
    public synchronized void a() {
    
    
        TimeUnit.SECONDS.sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
    
    
        log.debug("2");
    }
}
public static void main(String[] args) {
    
    
    Number n1 = new Number();
    Number n2 = new Number();
    // 不同对象，没有互斥
    new Thread(()->{
    
     n1.a(); }).start();
    new Thread(()->{
    
     n2.b(); }).start();
}

情况5：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
    
    
    // 锁Class
    public static synchronized void a() {
    
    
        TimeUnit.SECONDS.sleep(1);
        log.debug("1");
    }
    // 锁this
    public synchronized void b() {
    
    
        log.debug("2");
    }
}
public static void main(String[] args) {
    
    
    Number n1 = new Number();
    // 锁对象不同，没有互斥
    new Thread(()->{
    
     n1.a(); }).start();
    new Thread(()->{
    
     n1.b(); }).start();
}

情况6：1s 后12，或 2 1s后 1

@Slf4j(topic = "c.Number")
class Number{
    
    
    public static synchronized void a() {
    
    
        TimeUnit.SECONDS.sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
    
    
        log.debug("2");
    }
}
public static void main(String[] args) {
    
    
    Number n1 = new Number();
    new Thread(()->{
    
     n1.a(); }).start();
    new Thread(()->{
    
     n1.b(); }).start();
}

情况7：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
    
    
    public static synchronized void a() {
    
    
        TimeUnit.SECONDS.sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
    
    
        log.debug("2");
    }
}
public static void main(String[] args) {
    
    
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{
    
     n1.a(); }).start();
    new Thread(()->{
    
     n2.b(); }).start();
}

情况8：1s 后12，或 2 1s后 1

@Slf4j(topic = "c.Number")
class Number{
    
    
    public static synchronized void a() {
    
    
        TimeUnit.SECONDS.sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
    
    
        log.debug("2");
    }
}
public static void main(String[] args) {
    
    
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{
    
     n1.a(); }).start();
    new Thread(()->{
    
     n2.b(); }).start();
}

9. 一点点面试相关

内容引用：https://blog.csdn.net/qq_42764468/category_11756335.html?spm=1001.2014.3001.5482

1. Synchronized 对象锁？

synchronized 即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换。
Java中的每一个对象都可以作为锁：

对于同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前对象的Class对象。
对于同步方法块，锁是Synchonized括号里配置的对象。
当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。

2. Synchronized 同步方法？

在方法声明中设置synchronized同步关键字，保证其方法的代码执行流程是排他性的。任何时间只允许一个线程进入同步方法（临界区代码段），如果其他线程需要执行同一个方法，那么只能等待和排队。

3. Synchronized 同步方法的锁对象？

synchronized方法的同步锁实质上使用了this对象锁

A线程先持有object对象的锁，B线程如果在这时调用object对象的synchronized同步方法，则需等待，也就是同步;
在方法声明处添加synchronized并不是锁方法，而是锁当前类的对象，在Java中只有将对象作为锁，并没有锁方法这种说法;
在Java语言中，锁就是对象，对象可以映射成锁，哪个线程拿到这把锁，哪个线程就可以执行这个对象中的synchronized同步方法;
如果在 X 对象中访问了synchronized关键字声明非静态方法，则 X 对象就被当成锁;

5. Synchronized 静态同步方法的锁对象？

Java有两种对象：Object实例对象和Class对象。每个类运行时的类型信息用Class对象表示，它包含与类名称、继承关系、字段、方法有关的信息。
静态方法属于Class实例而不是单个Object实例，在静态方法内部是不可以访问Object实例的this引用的。所以，修饰static方法的synchronized关键字就没有办法获得Object实例的this对象的监视锁。
实际上，使用synchronized关键字修饰static方法时，synchronized的同步锁并不是普通Object对象的监视锁，而是类所对应的Class对象的监视锁。
为了以示区分，这里将Object对象的监视锁叫作对象锁，将Class对象的监视锁叫作类锁。当synchronized关键字修饰static方法时，同步锁为类锁；当synchronized关键字修饰普通的成员方法时，同步锁为对象锁。由于类的对象实例可以有很多，但是每个类只有一个Class实例，因此使用类锁作为synchronized的同步锁时会造成同一个JVM内的所有线程只能互斥地进入临界区段。
所以，使用synchronized关键字修饰static方法是非常粗粒度的同步机制。

6. 如果同步方法/块内的线程抛出异常，则对象锁自动释放？

public class SafeDemo {
    
    
    public synchronized void selfIncrement(){
    
    
        if(Thread.currentThread().getName().equals("t1")){
    
    
            System.out.println("t1 线程正在运行");
            int a=1;
            // 死循环，只要t1线程没有执行完这个方法，就不会释放锁
            while (a==1){
    
    
                
            }
        }else{
    
    
            System.out.println("t2 线程正在运行");
        }
    }
}

public class ThreadDemo {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        SafeDemo safeDemo = new SafeDemo();
        Thread t1 = new Thread(()->{
    
    
            safeDemo.selfIncrement();
        },"t1");

        Thread t2 = new Thread(()->{
    
    
            safeDemo.selfIncrement();
        },"t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

执行结果：t2线程得不到执行

t1 线程正在运行

此时，如果我们在同步方法中制造一个异常：

public class SafeDemo {
    
    
    public synchronized void selfIncrement(){
    
    
        if(Thread.currentThread().getName().equals("t1")){
    
    
            System.out.println("t1 线程正在运行");
            int a=1;
            while (a==1){
    
    
                Integer.parseInt("a");
            }
        }else{
    
    
            System.out.println("t2 线程正在运行");
        }
    }
}

执行结果：
在这里插入图片描述

线程t1出现异常并释放锁，线程t2进入方法正常输出，说明出现异常时，锁被自动释放了。

7. Synchronized同步方法和同步块，哪种更好？

同步块更好，这意味着同步块之外的代码是异步执行的，这比同步整个方法更提升代码的效率。请知道一条原则：同步的范围越小越好。
对于小的临界区，我们直接在方法声明中设置synchronized同步关键字，可以避免竞态条件的问题。但是对于较大的临界区代码段，为了执行效率，最好将同步方法分为小的临界区代码段。

public class TwoPlus {
    
    
    private int num1 = 0;
    private int num2 = 0;
    public synchronized void plus(int val1,int val2){
    
    
        this.num1 = num1+val1;
        this.num2 = num2+val2;
    }
}

临界区代码段包含对两个临界区资源的操作，这两个临界区资源分别为sum1和sum2。使用synchronized对plus(int val1,int val2)进行同步保护之后，进入临界区代码段的线程拥有sum1和sum2的操作权，并且是全部占用。一旦线程进入，当线程在操作sum1而没有操作sum2时，也将sum2的操作权白白占用，其他的线程由于没有进入临界区，只能看着sum2被闲置而不能去执行操作。
所以，将synchronized加在方法上，如果其保护的临界区代码段包含的临界区资源多于一个，就会造成临界区资源的闲置等待，进而会影响临界区代码段的吞吐量。为了提升吞吐量，可以将synchronized关键字放在函数体内，同步一个代码块。

public class TwoPlus {
    
    
    private int num1 = 0;
    private int num2 = 0;

    // 两把不同的锁对象
    private Object object1 = new Object();
    private Object object2 = new Object();

    public  void plus(int val1,int val2){
    
    
        synchronized (object1){
    
    
            this.num1 = num1+val1;
        }
        synchronized (object2){
    
    
            this.num2 = num2+val2;
        }
    }
}

改造之后，对两个独立的临界区资源sum1和sum2的加法操作可以并发执行了，在某一个时刻，不同的线程可以对sum1和sum2同时进行加法操作，提升了plus()方法的吞吐量。