Java并发编程 基础知识学习总结

Java并发编程一直是Java程序员必须懂但又是很难懂的技术内容，这部分的内容我也是反复学习了好几遍才能理解。本篇博客梳理一下最近从《Java 并发编程的艺术》和他人的博客学习Java并发编程的思路，本篇博客只梳理了Java并发整体的框架，以及罗列了重点内容和参考学习资料，由于篇幅问题就不对每个知识点做过多的深入。

一、进程与线程、并发与并行的概念，为什么要使用多线程

程序：一段静态的代码，一组指令的有序集合，它本身没有任何运行的含义，它只是一个静态的实体，是应用软件执行的蓝本。

　　进程：进程是CPU分配资源的最小单元，是程序的一次动态执行，它对应着从代码加载，执行至执行完毕的一个完整的过程，是一个动态的实体，它有自己的生命周期。它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消。进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它系统资源组成。进程在运行时创建的资源随着进程的终止而死亡。

　　线程：线程是CPU调度的基本单元，可以理解为进程的多条执行线索，每条线索又对应着各自独立的生命周期。线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

　　一个普通的Java SE程序启动后它就是一个进程，进程相当于一个空盒，它只提供资源装载的空间，具体的调度并不是由进程来完成的，而是由线程来完成的。一个java程序从main开始之后，进程启动，为整个程序提供各种资源，而此时将启动一个线程，这个线程就是主线程，它将调度资源，进行具体的操作。Thread、Runnable的开启的线程是主线程下的子线程，是父子关系，此时该java程序即为多线程的，这些线程共同进行资源的调度和执行。

　　并行：同时进行几个任务；并行是指两个或者多个事件在同一时刻发生

　　并发：根据虚拟机分配的时间片分时间运行不同的任务，同一时间只有一个任务在进行。并发是指两个或多个事件在同一时间间隔发生。

　　从图中可以清楚的看出，并发中，一个单核的CPU在同一时间只能执行一个线程中的任务，CPU通过给每个线程分配CPU时间片来实现这个机制的，时间片是CPU分配给各个线程的时间，因为时间片非常短，所以CPU通过不停地切换线程执行，让我们感觉多个线程是同时执行的，时间片一般是几十毫秒（ms）。

　　多个处理器、或集群，才能做到并行。单核单处理器无法并行执行程序，只能并发执行。

　　上下文切换：CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这个任务的状态。所以任务从保存再加载的过程就是一次上下文切换。

　　多线程程序会增加线程创建、上下文切换的开销以及资源调度的时间，在一些特定的环境下，多线程程序并不一定比单线程程序快。

　　为什么要使用多线程：

　　使用多线程的理由之一是和进程相比，它是一种非常花销小，切换快，更"节俭"的多任务操作方式。在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而在进程中的同时运行多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。
　　使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。
　　除了以上所说的优点外，不和进程比较，多线程程序作为一种多任务、并发的工作方式，当然有以下的优点：
　　1) 提高应用程序响应，充分利用多核CPU，提升CPU利用率。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
　　2) 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
　　3) 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改，以及程序功能的解耦。 

二、JMM/原子性、可见性、有序性

　　任何语言最终都是运行在处理器上，JVM虚拟机为了给开发者一个一致的编程内存模型，需要制定一套规则，这套规则可以在不同架构的机器上有不同实现，并且向上为程序员提供统一的JMM内存模型。

　　所以了解JMM内存模型也是了解Java并发原理的一个重点，其中了解指令重排，内存屏障，以及可见性原理尤为重要。

　　JMM只保证happens-before和as-if-serial规则，所以在多线程并发时，可能出现原子性，可见性以及有序性这三大问题。

　　Java提供了volatile、synchronized、lock等关键字方便程序员解决原子性、可见性、以及有序性等问题。

　　JMM的详细介绍见我之前的一篇博文：https://www.cnblogs.com/kukri/p/9109639.html

三、线程六大状态。线程启动、中断。

Java中线程的状态分为六种：

线程状态转换图：

1. 初始状态

　　实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

2.1. 运行状态——就绪

就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。

调用线程的start()方法，此线程进入就绪状态。

当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。

当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。

锁池里的线程拿到对象锁后，进入就绪状态。

2.2. 运行状态——运行中

线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

3. 阻塞状态

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

4. 等待

处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

5. 超时等待

处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

6. 终止状态

　　当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。

在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

线程启动

　　在运行线程之前首先要构造一个线程对象，线程对象在构造的时候需要提供线程所需要的属性，如线程所属的线程组、线程优先级、是否是Daemon线程等信息。一个新构造的线程对象是由其parent线程来进行空间分配的，而child线程继承了parent是否为Daemon、优先级和家在资源的contextClassLoader以及科技城的ThreadLocal，同时还会分配一个唯一的ID来表示这个child线程。至此，一个能够运行的线程对象就初始化好了，在堆内存中等待着运行。

通过Runnable接口创建线程类

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

（2）创建 Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

（3）调用线程对象的start()方法来启动该线程。用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于运行状态中的就绪状态，并没有真正运行，一旦得到cpu时间片，就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

　　即加入了同步队列中当前节点是否有前驱节点，如果返回true，则表示有线程比当前线程更早地请求获取锁，因此要等待前驱线程获取锁并释放锁才能继续获取锁，对应的就是把该线程加入同步队列中等待。

　　即 tryAcquire return false，取非以后 第一部分return true,然后进入第二部分，通过addWaiter把当前线程存为节点并加入到同步队列的尾部。

　　然后ac又是一个自旋，等待同步队列中的线程（节点）出队列的过程，且保证了队列的FIFO的特性。

　　第一次看这块的时候有疑问，就感觉AQS自带的acquire方法中的ac已经保证了FIFO，ReentrantLock集成AQS实现还怎么保证非公平和公平两种特性了。

　　后来仔细分析程序结构发现，acquire中的if判断，是先会去判断tryAcquire是否成功，根据&&（与）运算的特性，当且仅当tryAcquire失败（false），也就是if语句中的第一个判断条件为真时，才会去判断第二个条件，也就是加入同步队列自旋，这个同步队列是会保证FIFO也就保证了公平性的。但如果一个新来的线程，恰好在tryAcquire的CAS原子操作中成功获取了同步状态，那么他将“插队”，也就是说越过了同步队列中的所有节点，直接执行，这样就失去了公平性。所以虽然AQS机制自带了同步队列保证了一部分“公平性”，但tryAcquire中却没有保证公平性，所以ReentrantLock是否保证公平性是体现在tryAcquire的方法中的。

　　言归正传，公平锁虽然能保证线程锁的公平获取，但经过试验发现，会造成上下文的切换次数增加，造成更大的开销。非公平锁虽然可能造成线程“饥饿”，但极少的线程切换，保证了其更大的吞吐量。所以ReentrantLock默认设置为非公平锁。

　　在JDK5.0版本之前，重入锁的性能远远好于synchronized关键字，JDK6.0版本之后synchronized 得到了大量的优化，二者性能也不分伯仲，但是重入锁是可以完全替代synchronized关键字的。除此之外，重入锁又自带一系列高逼格操作：可中断响应、锁申请等待限时、公平锁、另外可以结合Condition来使用await()/signal() 提供更灵活的等待/通知机制，另外锁的释放获取也更加灵活。

4 读写锁

　　之前提到的锁基本上都是排他锁（独占锁），在同一时刻只允许一个线程进行访问，而读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。ReentrantReadWriteLock维护了一堆锁，读锁和写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升。

八、阻塞队列、ConcurrentHashMap、线程池

　　掌握了第六部分第七部分所讲的核心组件的原理后，就可以了解一下在实际生产环境中使用更多的API了。

1 阻塞队列 

　　阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。

　　1）支持阻塞的插入方法：意思是当队列满时，队列会阻塞插入元素的线程，直到队列不满。

　　2）支持阻塞的移除方法：意思是当队列为空时，获取元素的线程会等待队列变为非空。

　　阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取出元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器。　　

　　JDK7提供了7个阻塞队列。分别是

阻塞队列的方法对比非阻塞队列的方法

1.非阻塞队列中的几个主要方法：

　　add(E e):将元素e插入到队列末尾，如果插入成功，则返回true；如果插入失败（即队列已满），则会抛出异常；

　　remove()：移除队首元素，若移除成功，则返回true；如果移除失败（队列为空），则会抛出异常；

　　offer(E e)：将元素e插入到队列末尾，如果插入成功，则返回true；如果插入失败（即队列已满），则返回false；

　　poll()：移除并获取队首元素，若成功，则返回队首元素；否则返回null；

　　peek()：获取队首元素，若成功，则返回队首元素；否则返回null

　　对于非阻塞队列，一般情况下建议使用offer、poll和peek三个方法，不建议使用add和remove方法。因为使用offer、poll和peek三个方法可以通过返回值判断操作成功与否，而使用add和remove方法却不能达到这样的效果。注意，非阻塞队列中的方法都没有进行同步措施。

2.阻塞队列中的几个主要方法：

　　阻塞队列包括了非阻塞队列中的大部分方法，上面列举的5个方法在阻塞队列中都存在，但是要注意这5个方法在阻塞队列中都进行了同步措施。除此之外，阻塞队列提供了另外4个非常有用的方法：

　　put(E e)：put方法用来向队尾存入元素，如果队列满，则等待；

　　take()：take方法用来从队首取元素，如果队列为空，则等待；

　　offer(E e,long timeout, TimeUnit unit)：offer方法用来向队尾存入元素，如果队列满，则等待一定的时间，当时间期限达到时，如果还没有插入成功，则返回false；否则返回true；

　　poll(long timeout, TimeUnit unit)：poll方法用来从队首取元素，如果队列空，则等待一定的时间，当时间期限达到时，如果取到，则返回null；否则返回取得的元素；

阻塞队列的实现原理

　　JDK是使用通知模式实现的阻塞队列。所谓通知模式，就是当生产者往队列满的队列里添加元素时会阻塞住生产者，当消费者消费了一个队列中的元素后，会通知生产者当前队列可用。通过查看JDK源码发现ArrayBlockingQueue使用了Condition接口以及（await()/signal()）来实现。