JUC初次的学习总结

最新推荐文章于 2024-07-21 22:27:18 发布

努力学习的旭旭多多妹

最新推荐文章于 2024-07-21 22:27:18 发布

阅读量263

点赞数

文章标签： juc java 后端

本文链接：https://blog.csdn.net/m0_63106385/article/details/122090358

版权

JUC并发编程

一、JUC 简介

1.JUC介绍

在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。

JUC 就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。

2.进程与线程

进程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

线程

线程（thread）==是操作系统能够进行运算调度的最小单位。==它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

总结来说:

进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程— —资源分配的最小单位。

线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。

3.线程的状态

NEW,(新建)
RUNNABLE,（准备就绪）
BLOCKED,（阻塞）
WAITING,（不见不散）
TIMED_WAITING,（过时不候）
TERMINATED;(终结)

4.wait/sleep 的区别

（1）sleep 是 Thread 的静态方法，wait 是 Object 的方法，任何对象实例都能调用。

（2）sleep 不会释放锁，它也不需要占用锁。wait 会释放锁，但调用它的前提是当前线程占有锁(即代码要在 synchronized 中)。

（3）它们都可以被 interrupted 方法中断。

5.并发与并行

并发

并发(concurrent)指的是多个程序可以同时运行的现象，更细化的是多进程可以同时运行或者多指令可以同时运行。同一时刻多个线程在访问同一个资源，多个线程对一个点

例子：春运抢票电商秒杀…

并行：多项工作一起执行，之后再汇总

例子：泡方便面，电水壶烧水，一边撕调料倒入桶中

6.管程

管程(monitor)是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现).但是这样并不能保证进程以设计的顺序执行

JVM 中同步是基于进入和退出管程(monitor)对象实现的，每个对象都会有一个管程 (monitor)对象，管程(monitor)会随着 java 对象一同创建和销毁

执行线程首先要持有管程对象，然后才能执行方法，当方法完成之后会释放管程，方法在执行时候会持有管程，其他线程无法再获取同一个管程

7.用户线程和守护线程

用户线程:平时用到的普通线程,自定义线程

守护线程:运行在后台,是一种特殊的线程,比如垃圾回收

当主线程结束后,用户线程还在运行,JVM 存活
如果没有用户线程,都是守护线程,JVM 结束

二、Lock 接口

1.synchronized

synchronized 是 Java 中的关键字，是一种同步锁。

它修饰的对象有以下几种：

修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{} 括起来的代码，作用的对象是调用这个代码块的对象；
修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

synchronized 关键字不能被继承。

如果在父类中的某个方法使用了 synchronized 关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上 synchronized 关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。

修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
修改一个类，其作用的范围是synchronized 后面括号括起来的部分，作用的对象是这个类的所有对象。

如果一个代码块被 synchronized 修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；

2）线程执行发生异常，此时 JVM 会让线程自动释放锁。

案例：

class Ticket {
     //票数
     private int number = 30;
     //操作方法：卖票
     public synchronized void sale() {
     //判断：是否有票
     if(number > 0) {
     System.out.println(Thread.currentThread().getName()+" : 
    "+(number--)+" "+number);
 		}
 	}
}

2.lock

Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock 提供了比 synchronized 更多的功能。

Lock 与的 Synchronized 区别

Lock 不是 Java 语言内置的，synchronized 是 Java 语言的关键字，因此是内置特性。Lock 是一个类，通过这个类可以实现同步访问；
Lock 和 synchronized 有一点非常大的不同，采用 synchronized 不需要用户去手动释放锁，当 synchronized 方法或者 synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而 Lock 则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

lock()方法是平常使用得最多的一个方法，就是用来获取锁。

如果锁已被其他线程获取，则进行等待。采用 Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，==使用 Lock 必须在 try{}catch{}块中进行，==并且将释放锁的操作放在 finally 块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用 Lock 来进行同步的话，是以下面这种形式去使用的：

案例：

    //票数
    private int number = 30;
	//创建可重入锁
	private final ReentrantLock lock=new ReentrantLock();
	//卖票方法
	public void sale(){
        lock.lock();
    	try{
    		//处理任务
            .....
		}catch(Exception ex){
            .....
        }finally{
            lock.unlock(); //释放锁
		}
    }

3.newCondition

关键字 synchronized 与 wait()/notify()这两个方法一起使用可以实现等待/通知模式，

Lock 锁的 newContition()方法返回 Condition 对象，Condition 类也可以实现等待/通知模式。

用 notify()通知时，JVM 会随机唤醒某个等待的线程，使用 Condition 类可以进行选择性通知，Condition比较常用的两个方法：

await()会使当前线程等待,同时会释放锁,当其他线程调用 signal()时,线程会重新获得锁并继续执行。
signal()用于唤醒一个等待的线程。

注意：在调用 Condition 的 await()/signal()方法前，也需要线程持有相关的 Lock 锁，调用 await()后线程会释放这个锁，在singal()调用后会从当前 Condition 对象的等待队列中，唤醒一个线程，唤醒的线程尝试获得锁，一旦获得锁成功就继续执行。

4.ReentrantLock

ReentrantLock，意思是“可重入锁”，关于可重入锁的概念将在后面讲述。

==ReentrantLock 是唯一实现了 Lock 接口的类，==并且 ReentrantLock 提供了更多的方法。下面通过一些实例看具体看一下如何使用。

    //票数
    private int number = 30;
	//创建可重入锁
	private final ReentrantLock lock=new ReentrantLock();
	//卖票方法
	public void sale(){
        lock.lock();
    	try{
    		//处理任务
            .....
		}catch(Exception ex){
            .....
        }finally{
            lock.unlock(); //释放锁
		}
    }

5.小结（重点）

Lock 和 synchronized 有以下几点不同：

Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言实现；
synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁；
Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用 synchronized 时，等待的线程会一直等待下去，不能够响应中断；
通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。
Lock 可以提高多个线程进行读操作的效率。在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时 Lock 的性能要远远优于 synchronized。

三、线程间通信

线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。

1.synchronized方案

    /**
    * synchronized 关键字实现线程交替加减
    */

    class DemoClass{
     //加减对象
     private int number = 0;
     //加 1
     public synchronized void increment() {
     try {
     	if(number != 0){
     		this.wait();
     }
     number++;
     System.out.println("--------" + Thread.currentThread().getName() + "加一成
    功----------,值为:" + number);
     notifyAll();
     }catch (Exception e){
     		e.printStackTrace();
     	}
     }
     //减一
     public synchronized void decrement(){
     try {
     if(number == 0){
     	this.wait();
     }
     number--;
     System.out.println("--------" + Thread.currentThread().getName() + "减一成
    功----------,值为:" + number);
     notifyAll();
     }catch (Exception e){
     		e.printStackTrace();
     	}
     }
    }
    public class TestSynchronized {
     /**
     * 交替加减
     */
     public static void main(String[] args){
         DemoClass demoClass = new DemoClass();
         
         new Thread(() ->{
         for (int i = 0; i < 5; i++) {
         		demoClass.increment();
         	}
         }, "线程 A").start();
         
         new Thread(() ->{
         for (int i = 0; i < 5; i++) {
         		demoClass.decrement();
         	}
         }, "线程 B").start();
         }
    }

2.lock方案

package com.atguigu.test;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class DemoClass{
 //加减对象
 private int number = 0;
 //声明锁
 private Lock lock = new ReentrantLock();
 //声明钥匙
 private Condition condition = lock.newCondition();
 /**
 * 加 1
 */
 public void increment() {
 try {
 lock.lock();
 while (number != 0){
 condition.await();
 }
 number++;
 System.out.println("--------" + Thread.currentThread().getName() + "加一成
功----------,值为:" + number);
 condition.signalAll();
 }catch (Exception e){
 e.printStackTrace();
 }finally {
 lock.unlock();
 }
 }
 /**
 * 减一
 */
 public void decrement(){
 try {
 lock.lock();
 while (number == 0){
 condition.await();
 }
 number--;
 System.out.println("--------" + Thread.currentThread().getName() + "减一成
功----------,值为:" + number);
 condition.signalAll();
 }catch (Exception e){
 e.printStackTrace();
 }finally {
 lock.unlock();
 }
 }
}

3.线程间定制化通信

问题: A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照此顺序循环 10 轮

package com.atguigu.test;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class DemoClass{
 //通信对象:0--打印 A 1---打印 B 2----打印 C
 private int number = 0;
 //声明锁
 private Lock lock = new ReentrantLock();
 //声明钥匙 A
 private Condition conditionA = lock.newCondition();
 //声明钥匙 B
 private Condition conditionB = lock.newCondition();
 //声明钥匙 C
 private Condition conditionC = lock.newCondition();
 /**
 * A 打印 5 次
 */
 public void printA(int j){
 try {
 lock.lock();
 while (number != 0){
 conditionA.await();
 }
 System.out.println(Thread.currentThread().getName() + "输出 A,第" + j + "
轮开始");
 //输出 5 次 A
 for (int i = 0; i < 5; i++) {
 System.out.println("A");
 }
 //开始打印 B
 number = 1;
 //唤醒 B
 conditionB.signal();
 }catch (Exception e){
 e.printStackTrace();
 }finally {
 lock.unlock();
 }
 }
 /**
 * B 打印 10 次
 */
 public void printB(int j){
 try {
 lock.lock();
 while (number != 1){
 conditionB.await();
 }
 System.out.println(Thread.currentThread().getName() + "输出 B,第" + j + "
轮开始");
 //输出 10 次 B
 for (int i = 0; i < 10; i++) {
 System.out.println("B");
 }
 //开始打印 C
 number = 2;
 //唤醒 C
 conditionC.signal();
 }catch (Exception e){
 e.printStackTrace();
 }finally {
 lock.unlock();
 }
 }
 /**
 * C 打印 15 次
 */
 public void printC(int j){
 try {
 lock.lock();
 while (number != 2){
 conditionC.await();
 }
 System.out.println(Thread.currentThread().getName() + "输出 C,第" + j + "
轮开始");
 //输出 15 次 C
 for (int i = 0; i < 15; i++) {
 System.out.println("C");
 }
 System.out.println("-----------------------------------------");
 //开始打印 A
 number = 0;
 //唤醒 A
 conditionA.signal();
 }catch (Exception e){
 e.printStackTrace();
 }finally {
 lock.unlock();
 }
 }
}
测试类
package com.atguigu.test;
/**
* volatile 关键字实现线程交替加减
*/
public class TestVolatile {
 /**
 * 交替加减
 * @param args
 */
 public static void main(String[] args){
 DemoClass demoClass = new DemoClass();
 new Thread(() ->{
 for (int i = 1; i <= 10; i++) {
 demoClass.printA(i);
 }
 }, "A 线程").start();
 new Thread(() ->{
 for (int i = 1; i <= 10; i++) {
 demoClass.printB(i);
 }
 }, "B 线程").start();
 new Thread(() ->{
 for (int i = 1; i <= 10; i++) {
 demoClass.printC(i);
 }
 }, "C 线程").start();
 }
}

四、集合的线程安全

1.arraylist

package com.atguigu.test;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* 集合线程安全案例
*/
public class NotSafeDemo {
/**
* 多个线程同时对集合进行修改
* @param args
*/
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 100; i++) {
new Thread(() ->{
list.add(UUID.randomUUID().toString());
System.out.println(list);
}, "线程" + i).start();
}
}
}

异常内容

java.util.ConcurrentModificationException

原因

查看arraylist源码发现：add方法没有添加synchronized关键字修饰，说明是线程不安全的

解决arraylist线程安全问题的三种方案

1.vector

Vector 是矢量队列，它是 JDK1.0 版本添加的类。继承于 AbstractList，实现了 List, RandomAccess, Cloneable 这些接口。 Vector 继承了 AbstractList，实现了 List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。 Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。 RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在 Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。 Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆。

//List list = new ArrayList();
List list = new Vector();

2.collections

Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的

//List list = new ArrayList();
//List list = new Vector();
List list = Collections.synchronizedList(new ArrayList<>());

3.copyOnWriteArrayList（写实复制技术）

首先我们对 CopyOnWriteArrayList 进行学习,其特点如下:

它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和 ArrayList 不同的时，它具有以下特性：

它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。
它是线程安全的。
因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。
迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。
使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

//List list = new ArrayList();
//List list = new Vector();
//List list = Collections.synchronizedList(new ArrayList<>());
List list = new CopyOnWriteArrayList();

2.hashset

//Set<String> set = new HashSet<>();
Set<String> set = new CopyOnWriteSet();

3.hashmap

//Map<String,String> map=new HashMap<>();
Map<String,String> map=new ConcurrentHashMap<>();

4.线程安全机制

通过 volatile 和互斥锁来实现的。
通过“volatile 数组”来保存数据的。一个线程读取 volatile 数组时，总能看到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读取到的数据总是最新的”这个机制的保证。
通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile 数组”中，然后再“释放互斥锁”，就达到了保护数据的目的。

5.小结（重点）

1.线程安全与线程不安全集合

集合类型中存在线程安全与线程不安全的两种,

常见例如:

ArrayList ----- Vector

HashMap -----HashTable

但是以上都是通过 synchronized 关键字实现,效率较低

2.Collections 构建的线程安全集合

3.java.util.concurrent 并发包下 CopyOnWriteArrayList CopyOnWriteArraySet 类型,通过动态数组与线程安全方面保证线程安全

五、多线程锁

1.八种锁的问题案例


/**
* @Description: 8 锁
*
1 标准访问，先打印短信还是邮件
------sendSMS
------sendEmail
2 停 4 秒在短信方法内，先打印短信还是邮件
------sendSMS
------sendEmail
3 新增普通的 hello 方法，是先打短信还是 hello
------getHello
------sendSMS
4 现在有两部手机，先打印短信还是邮件
------sendEmail
------sendSMS
5 两个静态同步方法，1 部手机，先打印短信还是邮件
------sendSMS
------sendEmail
6 两个静态同步方法，2 部手机，先打印短信还是邮件
------sendSMS
------sendEmail
7 1 个静态同步方法,1 个普通同步方法，1 部手机，先打印短信还是邮件
------sendEmail
------sendSMS
8 1 个静态同步方法,1 个普通同步方法，2 部手机，先打印短信还是邮件
------sendEmail
------sendSMS
*/

class Phone {
 public static synchronized void sendSMS() throws Exception {
 //停留 4 秒
 TimeUnit.SECONDS.sleep(4);
 System.out.println("------sendSMS");
 }
 public synchronized void sendEmail() throws Exception {
 System.out.println("------sendEmail");
 }
 public void getHello() {
 System.out.println("------getHello");
 }
}

结论：

1.一个对象里面如果有多个 synchronized 方法，某一个时刻内，只要一个线程去调用其中的一个 synchronized 方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些 synchronized 方法 2.锁的是当前对象 this，被锁定后，其它的线程都不能进入到当前对象的其它的 synchronized 方法加个普通方法后发现和同步锁无关换成两个对象后，不是同一把锁了，情况立刻变化。

3.synchronized 实现同步的基础：Java 中的每一个对象都可以作为锁。

具体表现为以下 3 种形式。

1.对于普通同步方法，锁是当前实例对象。

2.对于静态同步方法，锁是当前类的 Class 对象。

3.对于同步方法块，锁是 Synchonized 括号里配置的对象

六、callable接口

1.创建线程的方法

创建 Thread 类
使用 Runnable接口
- 需要实现不返回任何内容的 run（）方法
- run（）不能引发异常
- 实现Runnable必须重写 run方法
使用callable接口
- 需要实现不返回任何内容的 run（）方法
- call（）方法可以引发异常
- 实现 Callable 而必须重写 call 方法
- 不能直接替换 runnable,因为 Thread 类的构造方法根本没有 Callable
线程池

例子：

//创建新类 MyThread 实现 runnable接口
class MyThread implements Runnable{
	@Override
	public void run() {
	}
}

//新类 MyThread2 实现 callable接口
class MyThread2 implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {
		return 200;
	}
}

2.future接口

当 call（）方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用 Future 对象。

要实现此接口，必须重写 5 种方法，这里列出了重要的方法,如下:

public boolean cancel（boolean mayInterrupt）：用于停止任务。如果尚未启动，它将停止任务。如果已启动，则仅在 mayInterrupt 为 true 时才会中断任务。
public Object get（）抛出 InterruptedException，ExecutionException：用于获取任务的结果。 ==如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。
public boolean isDone（）：如果任务完成，则返回 true，否则返回 false 可以看到 Callable 和 Future 做两件事-Callable 与 Runnable 类似，因为它封装了要在另一个线程上运行的任务，而 Future 用于存储从另一个线程获得的结果。实际上，future 也可以与 Runnable 一起使用。要创建线程，需要 Runnable。为了获得结果，需要 future。

3.FutureTask

Java 库具有具体的 FutureTask 类型，该类型实现 Runnable 和 Future，并方便地将两种功能组合在一起。可以通过为其构造函数提供 Callable 来创建 FutureTask。然后，将 FutureTask 对象提供给 Thread 的构造函数以创建 Thread 对象。因此，间接地使用 Callable 创建线程。

原理：

在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成

当主线程将来需要时，就可以通过 Future 对象获得后台作业的计算结果或者执行状态
一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。
仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法
一旦计算完成，就不能再重新开始或取消计算
get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常
get 只计算一次,因此 get 方法放到最后

七、juc三大辅助类

JUC 中提供了三种常用的辅助类，通过这些辅助类可以很好的解决线程数量过多时 Lock 锁的频繁操作。这三种辅助类为：

CountDownLatch: 减少计数
CyclicBarrier: 循环栅栏
Semaphore: 信号灯

1.减少计数 CountDownLatch

CountDownLatch 类可以设置一个计数器，然后通过 countDown 方法来进行减 1 的操作，使用 await 方法等待计数器不大于 0，然后继续执行 await 方法之后的语句。

CountDownLatch 主要有两个方法，当一个或多个线程调用 await 方法时，这些线程会阻塞
其它线程调用 countDown 方法会将计数器减 1(调用 countDown 方法的线程不会阻塞)
当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行

2.循环栅栏 cyclicBarrier

CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中 CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加 1 操作

3.信号灯 Semaphore

Semaphore 的构造方法中传入的第一个参数是最大信号量（可以看成最大线程池），每个信号量初始化为一个最多只能分发一个许可证。使用 acquire 方法获得许可证，release 方法释放许可

八、读写锁

p30看完

1.读写锁的概念

对共享资源有读和写的操作，且写操作没有读操作那么频繁。在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源；但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了。

JAVA 的并发包提供了读写锁 ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁

线程进入读锁的前提条件：

没有其他线程的写锁
没有写请求, 或者有写请求，但调用线程和持有锁的线程是同一个(可重入锁)。

线程进入写锁的前提条件：

没有其他线程的读锁
没有其他线程的写锁

九、阻塞队列

1.阻塞队列的概念

首先它是一个队列, 通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出；

当队列是空的，从队列中获取元素的操作将会被阻塞

当队列是满的，从队列中添加元素的操作将会被阻塞

试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素

试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增

2.BlockingQueue 核心方法

3.小结

1.在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤起

为什么需要 BlockingQueue? 在 concurrent 包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。使用后我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切 BlockingQueue 都给你一手包办了

十、ThreadPool 线程池

1.线程池的概念

线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

2.线程池的基本参数

corePoolSize 线程池的核心线程数
maximumPoolSize 能容纳的最大线程数
keepAliveTime 空闲线程存活时间
unit 存活的时间单位
workQueue 存放提交但未执行任务的队列
threadFactory 创建线程的工厂类
handler 等待队列满后的拒绝策略

3.创建线程池

创建线程池推荐适用 ThreadPoolExecutor 及其 7 个参数手动创建

corePoolSize 线程池的核心线程数
maximumPoolSize 能容纳的最大线程数
keepAliveTime 空闲线程存活时间 o unit 存活的时间单位
workQueue 存放提交但未执行任务的队列
threadFactory 创建线程的工厂类
handler 等待队列满后的拒绝策略
ueue? 在 concurrent 包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。使用后我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切 BlockingQueue 都给你一手包办了