多线程（初阶四：synchronized关键字）

旧城等待， 2024-02-17 10:20 45阅读 0赞

**目录**

一、加锁的目的

二、加锁和解锁

三、加锁后是否会出现线程安全问题

1、两个线程，针对不同对象加锁

2、一个线程加锁，一个线程不加锁

3、针对加锁操作的一些混淆理解

（1）多个线程调用同一个类的方法，对其方法里面的变量加锁

（2）Test类里的add方法里面，加锁的对象换成Test.class

（3）还可以把synchronized加到方法上

4、同一个线程用同一个锁对象加锁两次（可重入性的例子）

四、死锁

1、产生死锁的四个必要条件

2、死锁的三种经典场景

（1）一个线程，一把锁（针对锁是不可重入锁）

（2）两个线程，两把锁

（3）N个线程，M把锁

五、联系其他的相关知识点

1、StringBuffer 和 StringBuilder

2、C++加锁、解锁和java的区别

--------------------

## 一、加锁的目的 ##

**synchronized的两大特性：**

**（1）互斥性**

**（2）可重入性（后面讲）**

因为加锁具有**互斥**的特性，给一段代码加锁，当运行这段代码时，这里的代码在系统上的指令就会就会被打包在一起，等这些指令，执行完了，其他的指令操作才能进行。而这，也是加锁的目的：**把几个操作打包成一个原子的操作。**

--------------------

## 二、加锁和解锁 ##

我们想让一个变量自增10\_0000次，用两个线程来实现这一操作，分工各一半，

> 没有加锁的操作，是有线程问题的，因为两个线程修改同一个变量的原因。代码如下：
> 
>     public class ThreadDemo1 {
>         private static int count = 0;
>         public static void main(String[] args) throws InterruptedException {
>             Thread t1 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     count++;
>                 }
>             });
>             Thread t2 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     count++;
>                 }
>             });
>             t1.start();
>             t2.start();
>             t1.join();
>             t2.join();
>             System.out.println(count);
>         }
>     }
> 
> **执行效果：**
> 
> ![f0f689164e414ea7b9f86ebbca7ce5cd.png][]
> 
> count并不是我们预期的10\_0000。
> 
> **当我们给count++加上锁操作后的代码：**
> 
>     public class ThreadDemo1 {
>         private static int count = 0;
>         public static void main(String[] args) throws InterruptedException {
>             Object locker = new Object();
>             Thread t1 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     synchronized(locker) {
>                         count++;
>                     }
>                 }
>             });
>             Thread t2 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     synchronized(locker){
>                         count++;
>                     }
>                 }
>             });
>             t1.start();
>             t2.start();
>             t1.join();
>             t2.join();
>             System.out.println(count);
>         }
>     }
> 
> 执行效果：
> 
> ![84fe497ad9f7469eb44b71e3ca097e91.png][]
> 
> 是我们预期的效果。
> 
> **加锁的最核心规则：**对于一个线程，针对一个对象进行加锁，但也有其他线程，也尝试对这个对象进行加锁，就会产生阻塞，这时，我们就把这已现象称为**锁竞争 / 锁冲突**。
> 
> 例如下图，**都是针对locker对象进行加锁，这时就会产生锁竞争**
> 
> ![ca4c5b84fd174e1d979295c9085791af.png][]
> 
> 加锁和解锁的执行过程，针对上述代码，简单的画图展示一下：
> 
> ![bc5663c97aa94ec18cca9b034c46c7fe.png][]
> 
> 也就是把t1先上锁，把t1的这几个操作打包成一个原子，执行完它们才能执行t2。

**注意：**给加锁的对象是任意的引用类型都可以的，我们也可以随便起个对象，但是要记住加锁的核心，两个线程之间加锁的对象，是否是同一个对象，是同一个对象，就会产生锁竞争，反之则不会。

--------------------

## 三、加锁后是否会出现线程安全问题 ##

### 1、两个线程，针对不同对象加锁 ###

> 如下下代码，加锁用的不是同一个对象，则还是会存在线程安全问题
> 
>     public class ThreadDemo1 {
>         private static int count = 0;
>         public static void main(String[] args) throws InterruptedException {
>             Object locker1 = new Object();
>             Object locker2 = new Object();
>             Thread t1 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     synchronized(locker1) {
>                         count++;
>                     }
>                 }
>             });
>             Thread t2 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     synchronized(locker2){
>                         count++;
>                     }
>                 }
>             });
>             t1.start();
>             t2.start();
>             t1.join();
>             t2.join();
>             System.out.println(count);
>         }
>     }
> 
> **执行结果：**
> 
> ![006bff66a6fb48bf842163d4d04bc922.png][]
> 
> 我们可以看到，结果和我们预期的10\_0000不同，所以，还是存在线程安全问题。

### 2、一个线程加锁，一个线程不加锁 ###

> 如下代码，和上面代码差不多，做一些小小的改动
> 
>     public class ThreadDemo1 {
>         private static int count = 0;
>         public static void main(String[] args) throws InterruptedException {
>             Object locker1 = new Object();
>     //        Object locker2 = new Object();
>             Thread t1 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     synchronized(locker1) {
>                         count++;
>                     }
>                 }
>             });
>             Thread t2 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     count++;
>                 }
>             });
>             t1.start();
>             t2.start();
>             t1.join();
>             t2.join();
>             System.out.println(count);
>         }
>     }
> 
> 执行结果：
> 
> ![f7bfa4a45b1c46e8b478c12d0877ce08.png][]
> 
> 可以看到，和我们预期的结果不同，所以还是存在线程安全问题。

### 3、针对加锁操作的一些混淆理解 ###

#### （1）多个线程调用同一个类的方法，对其方法里面的变量加锁 ####

> 还是之前的代码模板，不过做了一些改动，把count放到Test t 对象中，在这里面count++，并且对其加锁，**加锁对象是 this**，其他线程再来调用Test中的方法。
> 
>     class Test {
>         public int count = 0;
>         public void add() {
>             synchronized(this) {
>                 count++;
>             }
>         }
>     }
>     public class ThreadDemo2 {
>         public static void main(String[] args) throws InterruptedException {
>             Test t = new Test();
>             Thread t1 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     t.add();
>                 }
>             });
>             Thread t2 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     t.add();
>                 }
>             });
>             t1.start();
>             t2.start();
>             t1.join();
>             t2.join();
>             System.out.println(t.count);
>         }
>     }
> 
> **执行效果：**
> 
> ![922ad522f0b14675874cdf2fd78b8e7c.png][]
> 
> 和我们的预期效果一样，这说明，这种情况是线程安全的。
> 
> **解释：**要解决这种情况的线程安全问题，核心还是上面所说的，看加锁是不是同一个对象，这里的Test类，add方法里对其加锁引用的对象是this，也就是当前Test类的实例对象，所有两个线程调用者方法的时候会产生锁竞争，结果也就可以达到我们的预期效果了。

#### （2）Test类里的add方法里面，加锁的对象换成Test.class ####

> 模板和之前差不多，只有一点小改动。代码如下：
> 
>     class Test {
>         public int count = 0;
>         public void add() {
>             synchronized(Test.class) {
>                 count++;
>             }
>         }
>     }
>     public class ThreadDemo2 {
>         public static void main(String[] args) throws InterruptedException {
>             Test t = new Test();
>             Thread t1 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     t.add();
>                 }
>             });
>             Thread t2 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     t.add();
>                 }
>             });
>             t1.start();
>             t2.start();
>             t1.join();
>             t2.join();
>             System.out.println(t.count);
>         }
>     }
> 
> **执行结果：**
> 
> ![c1cd80cc948b4976b7f8877a6b2ad1c5.png][]
> 
> 结果和我们预期的原因，是线程安全的情况。
> 
> **解释：**这里的 Test.class 是类对象（反射那一块的内容），而 t1 和 t2 拿到的都是同一个对象，就会有锁竞争，还是能保障线程安全的。

#### （3）还可以把synchronized加到方法上（静态和普通方法都行） ####

> 如图：
> 
> ![dcfcb7fedf9d4b8987668ecdd7b4daff.png][]
> 
> 表示锁的对象是当前方法所在的类，不过比较少用。

### 4、同一个线程用同一个锁对象加锁两次（可重入性的例子） ###

> **代码：**
> 
>     public class ThreadDemo1 {
>         public static void main(String[] args) {
>             Object locker = new Object();
>             Thread t1 = new Thread(() -> {
>                synchronized(locker)  {
>                     synchronized (locker) {
>                         System.out.println("hello");
>                     }
>                }
>             });
>             t1.start();
>         }
>     }
> 
> 看到这段代码，同一个线程用同一个对象加锁两次，我们的第一反应是不是肯定会一直阻塞等待，打印不出来 hello ？答案是否定的，能打印出 hello，我们来看看执行结果：
> 
> ![9dacabf51c6942e181781cee5b708938.png][]
> 
> 这是为什么呢？就是因为**synchronized有可重入性的特性**，**可以对一个线程用同一个锁对象加锁多次。**
> 
> 接下来，我们来解析一下这段代码，了解一下可重入性的内部操作。
> 
> **（1）**当我们第一次遇到synchronized的 “\{ ”时，是真正的加锁，在synchronized内部有一个计数器会自增一次（++）。此时计数器里的值：1
> 
> ![c3eeef860c8842d8ab68c76581b54045.png][]
> 
> **（2）**第二次遇到synchronized的 “ \{ ”，会判断要加锁的线程是否和正在持有锁线程是同一个线程，如果不是同一线程，则会阻塞等待正在持有锁线程，如果是同一线程，则synchronized内部的计数器会自增（++）的操作，就没别的操作了。此时计数器里的值：2
> 
> ![dcd25c55ff4149f3b7a11fa296b58dc7.png][]
> 
> **（3）**第一次遇到 “ \} ”，synchronized里的计数器自减一次（- -），此时计数器里的值：1 。因为计数器不为0，所以不会真的解锁。
> 
> ![8b3db9759fa04ac5b15177cca76b5291.png][]
> 
> **（4）**第二次遇到 “ \} ”，synchronized里的计数器自减一次（++），此时计数器的值：0。因为计数器归零了，会进行真正的解锁。
> 
> ![4a6c5f0bc9254b4a9c881c4024807468.png][]
> 
> 用计数器的方式，就能避免两个所之间的逻辑，失去锁的保护，也就是锁的可重入的特性。
> 
> **对于可重入锁来说，内部会持有两个信息：**
> 
> 1、当前这个锁被哪个线程持有的。
> 
> 2、加锁次数的计数器。

**注意：**这里的可重入性只针对java的synchronized关键字才有，底层的代码是用C++写的，而C++没有可重入性的这特性。

--------------------

## 四、死锁 ##

死锁是多线程代码中的一类经典问题，同样是经典的面试题。加锁能解决线程安全问题，但是如果加锁方式不当，就可能会产生死锁。

### 1、产生死锁的四个必要条件 ###

（1）**互斥使用**（获取锁的过程是互斥的，一个线程拿到了这把锁，其他线程想要拿到这把锁，就要阻塞，等待这个线程释放这把锁后，才能拿这把锁）

（2）**不可抢占**（一个线程拿到一把锁，其他线程不能强行把这把锁抢走）

（3）**请求保持**（一个线程拿到A锁，在持有A锁的前提下，同时尝试拿到B锁）

（4）**循环等待 / 环路等待**。

**破坏上述条件的难易程度：**

（1）互斥使用：锁的基本特性，不好破坏。

（2）不可抢占：锁的基本特性，不好破坏。

（3）请求保持：代码结构的原因，看实际需求，有时候能破坏，有时候不能破坏。

（4）循环等待：代码结构的原因，最好破坏，指定一定的规则即可避免循环等待。

### 2、死锁的三种经典场景 ###

#### （1）一个线程，一把锁（针对锁是不可重入锁） ####

> 当**锁是不可重入锁**，在C++中，一个线程对这把锁加锁两次，就会产生死锁
> 
> **代码：**
> 
>     public class ThreadDemo1 {
>         public static void main(String[] args) {
>             Object locker = new Object();
>             Thread t1 = new Thread(() -> {
>                synchronized(locker)  {
>                     synchronized (locker) {
>                         System.out.println("hello");
>                     }
>                }
>             });
>             t1.start();
>         }
>     }
> 
> 以上是针对的是不可重入锁的情况，在C++中逻辑大概是这逻辑，代码肯定是不同风格的。这种情况就会产生死锁的情况。
> 
> 这种情况也就像现实生活中，我们的钥匙锁房间里了，我们要想进入房间，就要拿到房间里的钥匙，但是房间是被锁着的，我们拿不到。
> 
> 代码逻辑：遇到第一个synchronized，进行加锁，代码里的内容遇到第二个synchronized，锁对象是一样的，就要阻塞，等待第一个synchronized里的代码执行完才能执行第二个synchronized里的代码，因为第二个被阻塞等待了，所以会一直这样的阻塞的等待下去。

#### （2）两个线程，两把锁 ####

**线程1获取到了锁A，线程2获取到了锁B，这两条件下，线程A想获取锁B，线程B想获取锁A。**这种情况，就会产生死锁。

**代码：**

public class ThreadDemo2 {
        public static void main(String[] args) {
            Object A = new Object();
            Object B = new Object();
    
            Thread t1 = new Thread(() -> {
                synchronized (A) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    synchronized (B) {
                        System.out.println("我获得了两把锁");
                    }
                }
            });
            Thread t2 = new Thread(() -> {
                synchronized (B) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    synchronized (A) {
                        System.out.println("我获得了两把锁");
                    }
                }
            });
            t1.start();
            t2.start();
        }
    }

**执行结果：**

![e948f66b4b30418b9c3b53a424a5c5ed.png][]

这里会一直阻塞等待，我们可以用jconsole看当前线程的状态

![95a236f5c10e4ef7903994238288736d.png][]

![461f03c74e8248bc81c7033416956221.png][]

这种情况，就像是钥匙锁车里了，车钥匙锁屋里了。

**代码解析：**线程1获取到了A锁，线程2也获得了B锁，因为线程的调度是随机的，所以接下来执行先执行线程1或者线程2，都行，我们以线程1为例子。当线程1想获取B锁时，因为线程2已经获取了锁B，就要等待线程2的锁B解锁后，线程1才能获取到B锁，但是线程2获取锁B后，它想获取锁A，因为锁A已经被线程1获取了，就要等线程1的A锁解锁后才能获取到锁A，这样就造成了阻塞等待，线程1等待B锁解锁，线程2等待锁A解锁，两个线程里的锁都无法解锁，就一直卡着不动。

**解决方案：**

破坏产生死锁四个必要条件之一：循环等待。

给加锁指定一定规则，例如：1线程获取A锁后，再获取B锁，2线程获取A锁后，再获取B锁。

**代码如下：**

public class ThreadDemo2 {
        public static void main(String[] args) {
            Object A = new Object();
            Object B = new Object();
    
            Thread t1 = new Thread(() -> {
                synchronized (A) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    synchronized (B) {
                        System.out.println("我获得了两把锁");
                    }
                }
            });
            Thread t2 = new Thread(() -> {
                synchronized (A) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    synchronized (B) {
                        System.out.println("我获得了两把锁");
                    }
                }
            });
            t1.start();
            t2.start();
        }
    }

**执行结果：**

![9239bd83095246089e4c50b53ae2da8c.png][]

#### （3）N个线程，M把锁 ####

> **哲学家就餐问题**
> 
> 假设有五个哲学家，五把锁，一个哲学家就是一个线程，一个筷子就是一把锁，如图：
> 
> ![ee81f8d7b15342678a5ea4c499b9953c.png][]
> 
> **规则：**一个哲学家要吃苗条的话要有一双筷子才能吃，而且只能拿哲学家左右两边的筷子，哲学家在吃面条的时候，不能被别的哲学家抢筷子。
> 
> 这时，如果每个哲学家，都同时拿起左边的筷子，这时，就没有多余的筷子给哲学家使用吃面条了，谁都不能吃到，谁都在等待，如图：
> 
> ![6b95624e0cd94008937e7a4e7ae60506.png][]
> 
> 这就像一个线程，自己已经持有了一把锁，但还在尝试获取一把锁，但是每个不同锁都被不同线程加锁了，这时就等待别的线程释放锁，但是大家也都在阻塞等待别的锁释放，就会产生死锁问题。
> 
> 那这时，要怎么办呢？只要破坏产生死锁的4个必要条件的其中一个，就能解决死锁的问题，其中破坏循环等待是最简单的。
> 
> **这时，我们规定，每个哲学家拿筷子编号比自己编号小的筷子，从编号为2的哲学家开始**，如图：
> 
> ![b710135ac9ff4bb0bb8b1b8f8c382480.png][]
> 
> 到最后，1号哲学家就不能拿筷子了，5号能吃到面条，等5号吃完，4号就能吃，依次类推，每个哲学家就都能吃到面条了。线程也差不多，给加锁指定一定的规则，就能有效避免循环等待问题了。

**注意：**解决死锁问题不止破坏四个必要条件这么点，解决死锁问题也有很多方案，例如：

（1）引入额外的筷子

（2）去掉一个哲学家

（3）引入计数器，限制同一时间多少个人吃面

（4）引入加锁顺序的规则（普适性高，方案容易落实）

（5）学校操作系统课中的 “银行家算法”（这个方案确实能解决死锁问题，但是实际开发中不建议这么搞，因为这算法太难了，可能你锁的逻辑没问题，算法有bug了，导致整个进程跑不了；理论可行，实践不推荐）

--------------------

## 五、联系其他的相关知识点 ##

### 1、StringBuffer 和 StringBuilder ###

StringBuffer是线程安全的，就是在一些关键方法上，加上了synchronized；StringBuilder不是线程安全的，就是在一些关键方法上，没加synchronized。

其实通俗的说是不是线程安全，并不严谨，例如上面的代码例子，一个线程加锁，一个线程不加锁，或者两个线程给不同的对象加锁，任然是线程不安全的。具体还是要看代码怎么写。

### 2、C++加锁、解锁和java的区别 ###

**C++：**它的加锁和解锁和java是不同的，在C++里，加锁：locker.lock() 解锁：locker.unlock()，他们的加锁和解锁是分开执行的，C++这种写法可能导致程序猿忘记调用unlock，或者unlock没执行到，这时就会产生很严重的bug，没解锁，其他加锁用和它一样对象的线程，就会一直等待。

**java：**它的是使用synchronized方法进行加锁，解锁的，这些操作已经打包好了，当synchronized代码块执行完后，就会自动释放锁，就不会有忘记或者没的解锁这种情况。

[f0f689164e414ea7b9f86ebbca7ce5cd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/4923641664e0417a84f7ab2b28108121.png
[84fe497ad9f7469eb44b71e3ca097e91.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/c8d392491c034f88b7ea211ba53510b7.png
[ca4c5b84fd174e1d979295c9085791af.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/f610c4426b2749ae985f654234dd73a0.png
[bc5663c97aa94ec18cca9b034c46c7fe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/7000d894c8a54a8da6c3c9af4fc54cc8.png
[006bff66a6fb48bf842163d4d04bc922.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/7a9275555a44491e8f1e06f196e9f56a.png
[f7bfa4a45b1c46e8b478c12d0877ce08.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/a55d13576bda4def901cff27791a0a46.png
[922ad522f0b14675874cdf2fd78b8e7c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/283629fcf727487581170f1147dbe970.png
[c1cd80cc948b4976b7f8877a6b2ad1c5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/c5f50e8b5b994478a80b488f9cb85e27.png
[dcfcb7fedf9d4b8987668ecdd7b4daff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/4cdbccc7fd55402ca809aa831b945422.png
[9dacabf51c6942e181781cee5b708938.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/6d7df9bb337f417eb5d0b63486d1b9e1.png
[c3eeef860c8842d8ab68c76581b54045.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/da2e7c0b348749d2a140ebe9a4167d69.png
[dcd25c55ff4149f3b7a11fa296b58dc7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/1a0eab1de88c48129f6e94484ccd836b.png
[8b3db9759fa04ac5b15177cca76b5291.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/86a038f0e32b46d788611f7f49658348.png
[4a6c5f0bc9254b4a9c881c4024807468.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/262b1ca981ed4b1f86133d4c58693233.png
[e948f66b4b30418b9c3b53a424a5c5ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/e168cfafce0348c38a0155271dab17c4.png
[95a236f5c10e4ef7903994238288736d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/adc526c2211b42d4b1eeff28193c5e14.png
[461f03c74e8248bc81c7033416956221.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/929a32ea4c914cec83da2fbc5cea3c72.png
[9239bd83095246089e4c50b53ae2da8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/25361a32cb744c2bb9b06ea04ca8cad6.png
[ee81f8d7b15342678a5ea4c499b9953c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/865cd262e14e4e0d85f75f0c901c2950.png
[6b95624e0cd94008937e7a4e7ae60506.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/589403c387044c7d801e6523c78b38e5.png
[b710135ac9ff4bb0bb8b1b8f8c382480.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/7548b2039d86461786ee6174c1fe23fb.png