本文共 5055 字，大约阅读时间需要 16 分钟。

我是 ABin-阿斌：写一生代码，创一世佳话，筑一揽芳华。 如果小伙伴们觉得我的文章有点 feel ，那就点个赞再走哦。

1 . JUC 是什么

• java.util.concurrent 在并发编程中使用的工具类
• JUC三大包： 并发包、并发原子包、并发lock包
  

2 . 进程/线程是什么

1. 进程

• 简单的说，就是后台运行的一个程序就是一共进程，是和操作系统有关。
• 例子： 写论文的时候，用 word 写论文，同时用 QQ 音乐放音乐，同时用 QQ 聊天，多个进程

2. 线程

• **线程：**通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统多个程序间并发执行的程度。
• 例子： word 如没有保存，停电关机，再通电后打开 word 可以恢复之前未保存的文档，word 也会检查你的拼写，两个线程：容灾备份，语法检查

3 . 并发/并行是什么

1. 并发

• 同一时刻多个线程在访问同一个资源，多个线程对一个点
• 例子：手机发布，限量抢购；春运抢票； 电商秒杀…

2. 并行

• 并行： 多项工作一起执行，之后再汇总
• 例子： 泡方便面，电水壶烧水，一边撕调料倒入桶中

4 . wait / sleep 区别

• wait ： 放开手去睡，放开手里的锁
• sleep ： 握紧手去睡，醒了手里还有锁

5 . 线程六大状态

1. NEW：(新建)
2. RUNNABLE：（准备就绪）
3. BLOCKED：（阻塞）
4. WAITING：（不见不散，会一直等待，直到来了）
5. TIMED_WAITING：（过时不候，只会等待一段时间 时间过了还不来，就走了）
6. TERMINATED：(终结)

6 . 复习售票问题

1. 题目 ：三个售票员 卖出 30张票

2. 口诀：线程 操作 资源类

3. 模板1.0

• 小标号代表对口诀的解释的顺序

public class JUC01_saleTicket01 {
       //main 一切程序的入口    public static void main(String[] args) {
           //1.2 初始化资源类        Ticket01 ticket = new Ticket01();        //1.3 线程：有三个售票员就新建三个线程,三个线程操作同一个资源类        //实际使用 Thread(Runnable target, String name) 新建进程        //使用匿名内部类，直接 new 一个 Runnable 接口对象        //进程 1        new Thread(new Runnable() {
               @Override            public void run() {
                   for (int i = 1; i <= 30; i++){
                       ticket.sale();                }            }        },"Thread_A").start();        //进程2        new Thread(new Runnable() {
               @Override            public void run() {
                   for (int i = 1; i <= 30; i++){
                       ticket.sale();                }            }        },"Thread_B").start();        //进程3        new Thread(new Runnable() {
               @Override            public void run() {
                   for (int i = 1; i <= 30; i++){
                       ticket.sale();                }            }        },"Thread_C").start();    }}//1.1 资源类//需要做到高内聚，就要把对自己的操作的方法、把对外提供的功能放在自己身上class Ticket01 {
       private int number = 30;    //资源类，自带了对外提供的功能    // 使用 synchronized 进行加锁    public synchronized void sale() {
   		//售票的业务逻辑        if (number > 0) {
               System.out.println(Thread.currentThread().getName() + " 卖出第：" + (number--) + "票，还剩下：" + number + "张");        }    }}

3. 模板2.0最终

• 因为 使用匿名内部类创建线程代码过于冗长，所以需要 使用 Lambda 表达式 进行优化
• 因为 使用 synchronized 加锁，会对整个方法加锁，粒度相对较大，所以 使用 lock 接口及其实现类 ReentrantLock(可重入锁)，来优化
• 优化后，如下：

public class JUC01_saleTicket01 {
       //main 一切程序的入口    public static void main(String[] args) {
           //1.2 初始化资源类        Ticket01 ticket = new Ticket01();        //1.3 线程：有三个售票员就新建三个线程,三个线程操作同一个资源类    	//使用  Lambda表达式 优化,不过为了思路不乱、清晰        // 最好先用匿名内部类写个例子，再变换        new Thread(()->{
   for (int i = 1; i <= 30; i++) ticket.sale();},"Thread_A").start();        new Thread(()->{
   for (int i = 1; i <= 30; i++) ticket.sale();},"Thread_B").start();        new Thread(()->{
   for (int i = 1; i <= 30; i++) ticket.sale();},"Thread_C").start();    }}//1.1 资源类//需要做到高内聚，就要把对自己的操作的方法、把对外提供的功能放在自己身上class Ticket01 {
       private int number = 30;    //不使用 synchronized ，因为加上  synchronized 的方法总所有代码都会被加锁    //改用 lock 接口及其实现类 ReentrantLock(可重入锁)，来优化    private Lock lock = new ReentrantLock();    //资源类，自带了对外提供的功能    public void sale() {
           // lock 模块        // 上锁        lock.lock();        try {
               //售票的业务逻辑            if (number > 0) {
                   System.out.println(Thread.currentThread().getName() + " 卖出第：" + (number--) + "票，还剩下：" + number + "张");            }        }catch (Exception e){
               e.printStackTrace();        }finally {
               // 开锁            lock.unlock();        }    }}

7 . 上述模板中的知识点补充

1. 关于 thread.start() 的问题

• 执行这句话，线程不会马上启动，只是代表这个线程进入就绪态
• 只有当 操作系统 和 CPU 底层调用到线程中的 run 方法才表示线程启动

2. Lambda表达式

• Lambda表达式，只能在实例化接口的时候，并且该接口中有且仅有一个方法的时候使用

• 使用时的口诀： 拷贝小括号，写死右箭头，落地大括号

• 以上述模板为例

// 起初初始化new Thread(new Runnable() {
               @Override            public void run() {
                   for (int i = 1; i <= 30; i++){
                       ticket.sale();                }            }},"Thread_A").start();// 使用 Lambda表达式new Thread(()->{
   for (int i = 1; i <= 30; i++) ticket.sale();},"Thread_A").start();

• 说明：
  1. 拷贝小括号： 照抄 run 方法后的小括号里所有的东西，（如果有参数也照抄，数据类型可以省略）
     例子： public int sum（int x，int y）{} =》（x，y）-> {}
  2. 写死右箭头
  3. 落地大括号： 就把原来方法 {} 中的照抄

2. @FunctionalInterface： 函数式接口

• 只有接口中有且仅有一个方法时，才可以使用 Lambda 表达式 进行实例化
• 如果一个接口中只有一个方法，在 java 底层会自动加上 @FunctionalInterface 注解，标明这是一个函数接口
• 如果一个接口被 @FunctionalInterface 标注，那么该接口中只能有一个方法，多写会报错

3. default

• 在 java8 以后支持在 函数接口 中默认实现该接口中的方法
• 例子：
  接口

// 接口@FunctionalInterfaceinterface FUN{
       public int sum(int X, int Y);    default int sum2(int X, int Y){
           return X + Y;    }}

调用（需要使用该接口的实例对象才能调用）

//调用FUN f = new FUN();f.sum2(1,2);

• 一个 函数接口 中可以有多个 默认的实现方法（default ）

4. static 静态方法

• 函数接口 里的静态方法必须时实现了的方法
• 例子：
  接口

// 接口@FunctionalInterfaceinterface FUN{
       public int sum(int X, int Y);    public static int sum2(int X, int Y){
           return X + Y;    }}

调用（只能使用该接口名才能调用）

//调用FUN.sum2(1,2);

• 一个 函数接口 可以有多个静态方法

转载地址：http://uklez.baihongyu.com/