多线程基础必要知识点！看了学习多线程事半功倍

傷城~ 2021-09-15 07:30 220阅读 0赞

# 前言 #

不小心就鸽了几天没有更新了，这个星期回家咯。在学校的日子要努力一点才行!

> 只有光头才能变强

回顾前面：

*  [多线程三分钟就可以入个门了！][Link 1]
 *  [Thread源码剖析][Thread]

本文章的知识主要参考《Java并发编程实战》这本书的前4章，这本书的前4章都是讲解并发的基础的。要是能好好理解这些基础，那么我们往后的学习就会事半功倍。

当然了，《Java并发编程实战》可以说是非常经典的一本书。**我是未能完全理解的，在这也仅仅是抛砖引玉**。想要更加全面地理解我下面所说的知识点，可以去阅读一下这本书，总的来说还是不错的。

首先来预览一下《Java并发编程实战》前4章的目录究竟在讲什么吧：

**第1章　简介**

*  1.1　并发简史
 *  1.2　线程的优势
 *  1.2.1　发挥多处理器的强大能力
 *  1.2.2　建模的简单性
 *  1.2.3　异步事件的简化处理
 *  1.2.4　响应更灵敏的用户界面
 *  1.3　线程带来的风险
 *  1.3.1　安全性问题
 *  1.3.2　活跃性问题
 *  1.3.3　性能问题
 *  1.4　线程无处不在

ps：**这一部分我就不讲了**，主要是引出我们接下来的知识点，有兴趣的同学可翻看原书~

**第2章　线程安全性**

*  2.1　什么是线程安全性
 *  2.2　原子性
 *  2.2.1　竞态条件
 *  2.2.2　示例：延迟初始化中的竞态条件
 *  2.2.3　复合操作
 *  2.3　加锁机制
 *  2.3.1　内置锁
 *  2.3.2　重入
 *  2.4　用锁来保护状态
 *  2.5　活跃性与性能

**第3章　对象的共享**

*  3.1　可见性
 *  3.1.1　失效数据
 *  3.1.2　非原子的64位操作
 *  3.1.3　加锁与可见性
 *  3.1.4　Volatile变量
 *  3.2　发布与逸出
 *  3.3　线程封闭
 *  3.3.1　Ad-hoc线程封闭
 *  3.3.2　栈封闭
 *  3.3.3　ThreadLocal类
 *  3.4　不变性
 *  3.4.1　Final域
 *  3.4.2　示例：使用Volatile类型来发布不可变对象
 *  3.5　安全发布
 *  3.5.1　不正确的发布：正确的对象被破坏
 *  3.5.2 　不可变对象与初始化安全性
 *  3.5.3　安全发布的常用模式
 *  3.5.4　事实不可变对象
 *  3.5.5　可变对象
 *  3.5.6　安全地共享对象

**第4章　对象的组合**

*  4.1　设计线程安全的类
 *  4.1.1　收集同步需求
 *  4.1.2　依赖状态的操作
 *  4.1.3　状态的所有权
 *  4.2　实例封闭
 *  4.2.1　Java监视器模式
 *  4.2.2　示例：车辆追踪
 *  4.3　线程安全性的委托
 *  4.3.1　示例：基于委托的车辆追踪器
 *  4.3.2　独立的状态变量
 *  4.3.3　当委托失效时
 *  4.3.4　发布底层的状态变量
 *  4.3.5　示例：发布状态的车辆追踪器
 *  4.4　在现有的线程安全类中添加功能
 *  4.4.1　客户端加锁机制
 *  4.4.2　组合
 *  4.5　将同步策略文档化

那么接下来我们就开始吧~

# 一、使用多线程遇到的问题 #

## 1.1线程安全问题 ##

在前面的文章中已经讲解了线程【[多线程三分钟就可以入个门了！][Link 1]】，多线程主要是为了提高我们**应用程序的使用率**。但同时，这会给我们**带来很多安全问题**！

如果我们在**单线程**中以“顺序”(串行–>独占)的方式执行代码**是没有任何问题**的。但是到了多线程的环境下(并行)，如果没有设计和控制得好，就会给我们带来很多**意想不到的状况，也就是线程安全性问题**

因为在多线程的环境下，线程是**交替执行**的，一般他们会使用多个线程**执行相同的代码**。如果在此相同的代码里边有着**共享的变量**，或者一些**组合操作**，我们想要的**正确**结果就很容易出现了问题

简单举个例子：

*  **下面的程序在单线程中跑起来，是没有问题的**。

public class UnsafeCountingServlet extends GenericServlet implements Servlet { 
        private long count = 0;
    
        public long getCount() {
            return count;
        }
    
        public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
    
            ++count;
            // To something else...
        }
    }

但是在多线程环境下跑起来，它的**count值计算**就不对了！

首先，它**共享**了count这个变量，其次来说`++count;`这是一个**组合的操作**(注意，**它并非是原子性**）

*  `++count`实际上的操作是这样子的：  
    
    
     *  读取count值
     *  将值+1
     *  将计算结果写入count

于是多线程执行的时候**很可能**就会有这样的情况：

*  当线程A读取到count的值是8的时候，**同时**线程B也进去这个方法上了，也是读取到count的值为8
 *  它俩都对值进行加1
 *  将计算结果写入到count上。但是，**写入到count上的结果是9**
 *  也就是说：两个线程进来了，但是**正确的结果是应该返回10**，而它返回了9，这是不正常的！

如果说：当多个线程访问某个类的时候，这个类**始终**能表现出**正确的行为**，那么这个类就是线程安全的！

有个原则：**能使用JDK提供的线程安全机制，就使用JDK的**。

当然了，此部分其实是我们**学习多线程最重要的环节**，这里我就不详细说了。这里只是一个总览，这些知识点在后面的学习中都会遇到~~~

## 1.3性能问题 ##

使用多线程我们的目的就是为了提高应用程序的使用率，但是如果多线程的代码**没有好好设计**的话，那未必会提高效率。**反而降低了效率，甚至会造成死锁**！

就比如说我们的Servlet，一个Servlet对象可以处理多个请求的，**Servlet显然是一个天然支持多线程的**。

又以下面的例子来说吧：

从上面我们已经说了，上面**这个类是线程不安全的**。最简单的方式：如果我们在service方法上加上JDK为我们提供的内置锁synchronized，那么我们就可以实现线程安全了。

public class UnsafeCountingServlet extends GenericServlet implements Servlet { 
        private long count = 0;
    
        public long getCount() {
            return count;
        }
    
        public void synchronized service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
    
            ++count;
            // To something else...
        }
    }

虽然实现了线程安全了，但是这会带来**很严重的性能问题**：

*  每个请求都得**等待**上一个请求的service方法**处理了以后**才可以完成对应的操作

这就导致了：我们完成一个小小的功能，使用了多线程的目的是想要提高效率，但现在**没有把握得当，却带来严重的性能问题**！

在使用多线程的时候：更严重的时候还有**死锁**(程序就卡住不动了)。

这些都是我们接下来要学习的地方：**学习使用哪种同步机制来实现线程安全，并且性能是提高了而不是降低了**~

# 二、对象的发布与逸出 #

书上是这样定义发布和逸出的：

> 发布(publish) 使对象能够在当前作用域之外的代码中使用
> 
> 逸出(escape) 当某个不应该发布的对象被发布了

常见**逸出**的有下面几种方式：

*  静态域逸出
 *  public修饰的get方法
 *  方法参数传递
 *  隐式的this

**静态域逸出：**

![nSAMemW.png][]

**public修饰get方法：**

![Se5r4TX.png][]

**方法参数传递我就不再演示了**，因为把对象传递过去给另外的方法，已经是逸出了~

下面来看看该书给出**this逸出的例子**：

![2L0Blk6.png][]

**逸出就是本不应该发布对象的地方，把对象发布了**。导致我们的**数据泄露**出去了，这就造成了一个**安全隐患**！理解起来是不是简单了一丢丢？

## 2.1安全发布对象 ##

上面谈到了好几种逸出的情况，我们接下来来谈谈**如何安全发布对象**。

安全发布对象有几种常见的方式：

*  **在静态域中直接初始化** ： `public static Person = new Person()`;  
    
    
     *  静态初始化由JVM在类的初始化阶段就执行了，**JVM内部存在着同步机制**，致使这种方式我们可以安全发布对象
 *  对应的引用保存到**volatile或者AtomicReferance引用中**  
    
    
     *  保证了该对象的引用的可见性和原子性
 *  **由final修饰**  
    
    
     *  该对象是不可变的，那么线程就一定是安全的，所以是安全发布~
 *  **由锁来保护**  
    
    
     *  发布和使用的时候都需要加锁，这样才保证能够该对象不会逸出

# 三、解决多线程遇到的问题 #

从上面我们就可以看到，使用多线程会把我们的系统搞得挺复杂的。是需要我们去处理很多事情，为了防止多线程给我们带来的安全和性能的问题~

下面就来**简单总结**一下我们需要哪些知识点来解决多线程遇到的问题。

## 3.1简述解决线程安全性的办法 ##

使用多线程就一定要**保证我们的线程是安全的**，这是最重要的地方！

在Java中，我们一般会有下面这么几种办法来实现线程安全问题：

*  无状态(**没有共享变量**)
 *  使用final使该引用变量不可变(如果该对象引用也引用了其他的对象，那么无论是发布或者使用时都需要加锁)
 *  加锁(内置锁，显示Lock锁)
 *  使用JDK为我们提供的类来实现线程安全(此部分的类就很多了)  
    
    
     *  原子性（就比如上面的`count++`操作，可以使用AtomicLong来实现原子性，那么在增加的时候就不会出差错了！)
     *  容器(ConcurrentHashMap等等…)
     *  ……
 *  …等等

## 3.2原子性和可见性 ##

何为原子性？何为可见性？当初我在[ConcurrentHashMap基于JDK1.8源码剖析][ConcurrentHashMap_JDK1.8]中已经简单说了一下了。不了解的同学可以进去看看。

### 3.2.1原子性 ###

在多线程中很多时候都是因为某个操作不是原子性的，使数据混乱出错。如果操作的数据是原子性的，那么就可以很大程度上避免了线程安全问题了！

*  `count++`，先读取，后自增，再赋值。**如果该操作是原子性的，那么就可以说线程安全了(因为没有中间的三部环节，一步到位【原子性】**~

**原子性**就是执行**某一个操作是不可分割的**，  
\- 比如上面所说的`count++`操作，它就不是一个原子性的操作，它是分成了三个步骤的来实现这个操作的~  
\- **JDK中有atomic包提供给我们实现原子性操作**~

![T9ldaT8.png][]

也有人将其做成了表格来分类，我们来看看：

![图片来源：<a href=][a href]https://blog.csdn.net/eson\_15/article/details/51553338” title=”” />

使用这些类相关的操作也可以进他的博客去看看：

*  [https://blog.csdn.net/eson\_15/article/details/51553338][https_blog.csdn.net_eson_15_article_details_51553338]

### 3.2.2可见性 ###

对于**可见性**，Java提供了一个关键字：volatile给我们使用~

*  我们可以简单认为：volatile是一种**轻量级的同步机制**

volatile经典总结：**volatile仅仅用来保证该变量对所有线程的可见性，但不保证原子性**

我们将其拆开来解释一下：

*  保证**该变量对所有线程的可见性**  
    
    
     *  在多线程的环境下：当这个变量修改时，**所有的线程都会知道该变量被修改了**，也就是所谓的“可见性”
 *  不保证原子性  
    
    
     *  修改变量(赋值)**实质上**是在JVM中**分了好几步**，而**在这几步内(从装载变量到修改)，它是不安全的**。

使用了volatile修饰的变量**保证了三点**：

*  **一旦你完成写入，任何访问这个字段的线程将会得到最新的值**
 *  在你写入前，**会保证所有之前发生的事已经发生**，并且任何更新过的数据值也是可见的，因为内存屏障会把之前的写入值都刷新到缓存。
 *  **volatile可以防止重排序**(重排序指的就是：程序执行的时候，CPU、编译器可能会**对执行顺序做一些调整**，导致执行的顺序并不是从上往下的。从而出现了一些意想不到的效果)。而如果声明了volatile，那么CPU、编译器就会知道**这个变量是共享的**，不会被缓存在寄存器或者其他不可见的地方。

一般来说，**volatile大多用于标志位上(判断操作)**,满足下面的条件才应该使用volatile修饰变量：

*  **修改变量时不依赖变量的当前值**(因为volatile是不保证原子性的)
 *  **该变量不会纳入到不变性条件中**(该变量是可变的)
 *  **在访问变量的时候不需要加锁**(加锁就没必要使用volatile这种轻量级同步机制了)

参考资料：

*  [http://www.cnblogs.com/Mainz/p/3556430.html][http_www.cnblogs.com_Mainz_p_3556430.html]
 *  [https://www.cnblogs.com/Mainz/p/3546347.html][https_www.cnblogs.com_Mainz_p_3546347.html]
 *  [http://www.dataguru.cn/java-865024-1-1.html][http_www.dataguru.cn_java-865024-1-1.html]

## 3.3线程封闭 ##

在多线程的环境下，只要我们**不使用成员变量(不共享数据)**,那么就不会出现线程安全的问题了。

就用我们熟悉的Servlet来举例子，写了那么多的Servlet，你见过我们说要加锁吗？？我们所有的数据都是在方法(栈封闭)上操作的，**每个线程都拥有自己的变量，互不干扰**！

![AUuWIK5.png][]

在方法上操作，**只要我们保证不要在栈(方法)上发布对象**(每个变量的作用域仅仅停留在当前的方法上)，那么我们的线程就是安全的

在线程封闭上还有另一种方法，就是我之前写过的：[ThreadLocal就是这么简单][ThreadLocal]

使用这个类的API就可以**保证每个线程自己独占一个变量**。(详情去读上面的文章即可)~

## 3.4不变性 ##

> 不可变对象一定线程安全的。

上面我们共享的变量都是可变的，正由于是可变的才会出现线程安全问题。如果**该状态是不可变的**，那么**随便多个线程访问都是没有问题的**！

Java提供了final修饰符给我们使用，final的身影我们可能就见得比较多了，但值得说明的是：

*  **final仅仅是不能修改该变量的引用，但是引用里边的数据是可以改的!**

就好像下面这个HashMap，用final修饰了。但是它仅仅保证了该**对象引用**`hashMap变量`所指向是不可变的，但是hashMap内部的数据是可变的，也就是说：可以add，remove等等操作到集合中~~~

*  因此，仅仅只能够说明**hashMap是一个不可变的对象引用**

final HashMap<Person> hashMap = new HashMap<>();

**不可变的对象引用**在使用的时候还是**需要加锁**的

*  或者把Person也设计成是一个线程安全的类~
 *  因为内部的状态是可变的，**不加锁或者Person不是线程安全类，操作都是有危险的**！

要想将对象设计成不可变对象，那么要满足下面三个条件：

*  **对象创建后状态就不能修改**
 *  **对象所有的域都是final修饰的**
 *  **对象是正确创建的**(没有this引用逸出)

String在我们学习的过程中我们就知道它是一个**不可变对象**，但是它没有遵循第二点(对象所有的域都是final修饰的)，因为JVM在内部做了优化的。但是我们如果是要自己设计不可变对象，是需要满足三个条件的。

![DclDJNz.png][]

## 3.5线程安全性委托 ##

很多时候我们要实现线程安全**未必就需要自己加锁，自己来设计**。

我们可以使用JDK给我们提供的对象来完成线程安全的设计：

![ESSyxEd.png][]

非常多的”工具类”供我们使用，这些在往后的学习中都会有所介绍的~~这里就不介绍了

# 四、最后 #

正确使用多线程能够提高我们应用程序的效率，同时给我们会带来非常多的问题，这些都是我们在使用多线程之前需要注意的地方。

无论是不变性、可见性、原子性、线程封闭、委托这些都是实现线程安全的一种**手段**。要合理地使用这些手段，我们的程序才可以更加健壮！

可以发现的是，上面在很多的地方说到了：**锁**。但我没有介绍它，因为我打算**留在下一篇**来写，敬请期待~~~

书上前4章花了65页来讲解，而我只用了一篇文章来概括，这是远远不够的，想要继续深入的同学可以去阅读书籍~

之前在学习操作系统的时候根据《计算机操作系统-汤小丹》这本书也做了一点点笔记，都是比较**浅显的知识点**。或许对大家有帮助

*  [操作系统第一篇【引论】][Link 2]
 *  [操作系统第二篇【进程管理】][Link 3]
 *  [操作系统第三篇【线程】][Link 4]
 *  [操作系统第四篇【处理机调度】][Link 5]
 *  [操作系统第五篇【死锁】][Link 6]
 *  [操作系统第六篇【存储器管理】][Link 7]
 *  [操作系统第七篇【设备管理】][Link 8]

参考资料：

*  《Java核心技术卷一》
 *  《Java并发编程实战》
 *  《计算机操作系统-汤小丹》

> 如果文章有错的地方欢迎指正，大家互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同学，可以**关注微信公众号:Java3y**。为了大家方便，刚新建了一下**qq群：742919422**，大家也可以去交流交流。谢谢支持了！希望能多介绍给其他有需要的朋友

**文章的目录导航**：

*  [https://zhongfucheng.bitcron.com/post/shou-ji/wen-zhang-dao-hang][https_zhongfucheng.bitcron.com_post_shou-ji_wen-zhang-dao-hang]

[Link 1]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484186&idx=1&sn=2a7b937e6d3b1623aceac199d3e402f9&chksm=ebd7421bdca0cb0d6206db8c7f063c884c3f0b285975c8e896fde424660b4ccb88da1549f32c#rd
[Thread]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484190&idx=1&sn=ab7301e393aa7762be9ef80d30c5fb7a&chksm=ebd7421fdca0cb09f4a880064a8610416df414ea25284e6d5142ea659e4e7e669632cfed4050#rd
[nSAMemW.png]: https://i.imgur.com/nSAMemW.png
[Se5r4TX.png]: https://i.imgur.com/Se5r4TX.png
[2L0Blk6.png]: https://i.imgur.com/2L0Blk6.png
[ConcurrentHashMap_JDK1.8]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484161&idx=1&sn=6f52fb1f714f3ffd2f96a5ee4ebab146&chksm=ebd74200dca0cb16288db11f566cb53cafc580e08fe1c570e0200058e78676f527c014ffef41#rd
[T9ldaT8.png]: https://i.imgur.com/T9ldaT8.png
[a href]: https://i.imgur.com/5fMO7CU.png
[https_blog.csdn.net_eson_15_article_details_51553338]: https://blog.csdn.net/eson_15/article/details/51553338
[http_www.cnblogs.com_Mainz_p_3556430.html]: http://www.cnblogs.com/Mainz/p/3556430.html
[https_www.cnblogs.com_Mainz_p_3546347.html]: https://www.cnblogs.com/Mainz/p/3546347.html
[http_www.dataguru.cn_java-865024-1-1.html]: http://www.dataguru.cn/java-865024-1-1.html
[AUuWIK5.png]: https://i.imgur.com/AUuWIK5.png
[ThreadLocal]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484118&idx=1&sn=da3e4c4cfd0642687c5d7bcef543fe5b&chksm=ebd743d7dca0cac19a82c7b29b5b22c4b902e9e53bd785d066b625b4272af2a6598a0cc0f38e#rd
[DclDJNz.png]: https://i.imgur.com/DclDJNz.png
[ESSyxEd.png]: https://i.imgur.com/ESSyxEd.png
[Link 2]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484186&idx=2&sn=e272d8e95a5677c75c21b058a064f0f8&chksm=ebd7421bdca0cb0d9d15da009894c8d1b503acbeb601af180ad7408bf2ff191de4995cccf0aa#rd
[Link 3]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484186&idx=3&sn=cefa7781f34e2244b5eea83b7e242c3e&chksm=ebd7421bdca0cb0de76d3f1705f43cbdd41d0c9eb58cf4b55f32793d4f9f8ae2efbd539c8c30#rd
[Link 4]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484186&idx=4&sn=c8d83a508f7a87ad49dcfd6965779129&chksm=ebd7421bdca0cb0d309a3c444240b3677755c7b3083e9dce5e7d70d8d5dbb6e57bd14a7f38fc#rd
[Link 5]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484186&idx=5&sn=54bda03c277af5283c9daff07fff4246&chksm=ebd7421bdca0cb0da6de8e2211049a7b9e95b0d4f5a76b9f6c68682d8648ecc71d92b12bcde3#rd
[Link 6]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484186&idx=6&sn=fbe59571e8469fe953404cc632723646&chksm=ebd7421bdca0cb0d85c3a6651e765821d8e0b8aba43e2358d6f3be550a10e0b3ef02bc603715#rd
[Link 7]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484186&idx=7&sn=3e027ee134e65c5cfae67218ce69a06a&chksm=ebd7421bdca0cb0d29437cad1483f5f59cf1ea9da57bf64900e52a2cd3d63e8fbaaeef9f2c51#rd
[Link 8]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484186&idx=8&sn=01562e2dee725260460898e31edd8d29&chksm=ebd7421bdca0cb0d9011b0e63154b0052ede92030537c9be3fcf3a34dac059f79926bdaf98ca#rd
[https_zhongfucheng.bitcron.com_post_shou-ji_wen-zhang-dao-hang]: https://zhongfucheng.bitcron.com/post/shou-ji/wen-zhang-dao-hang