1、什么是JUC？

java.util.concurrent包是在并发编程中使用的工具类，有以下三个包：

• java.util.concurrent
• java.util.concurrent.atomic
• java.util.concurrent.locks

2、进程和线程

进程/线程

• 进程
  • 进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。
  • 进程是操作系统动态执行的基本单元，是系统资源分配的基本单位。
  • 一个进程往往可以有多个线程，一个进程至少包含一个线程。
  • Java默认有两个线程：main()主线程、GC线程
• 线程
  • 通常一个进程中可以包含若干个线程，一个进程中至少有一个线程，线程可以共享进程所有拥有的资源。
  • 进程是资源分配的基本单位，而线程是CPU调度的基本单位。
  • 由于线程比进程小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统多个程序间并发执行的程度。

    Java真的能开启线程吗？ 不能。 本地方法，底层的C++，Java无法直接操作硬件。

白话：

• 进程：就是操作系统中运行的一个程序。
• 线程：每个进程中都存在一个或者多个线程。

并发/并行

并发和并行是两个非常容易混淆的概念。它们都可以表示两个或多个任务一起执行，但是偏重点不同：

• 并发（多线程操作同一个资源）
  • CPU一核，模拟出来多条线程，并发是逻辑上的同时发生。
  • 偏重于多个任务交替执行，而多个任务之间有可能还是串行的。
• 并行（多个人一起行走）
  • 物理上的同时发生，其偏重点在于”同时执行”。
  • CPU多核，多个线程可以同时执行。 ```java package com.wang.demo01

public class Test1{ public static void main(String[] args){ //获取CPU的核数 //CPU密集型，IO密集型 System.out.println(Runtime.getRuntime().availableProcessors()); } }

严格意义上来说，并行的多个任务是真实地同时执行，而对于并发来说，这个过程只是交替的，系统会不停地在两者间切换。但对于外部观察者来说，即使多个任务是串行并发的，也会造成是多个任务并行执行的错觉（因为切换的时间足够短）。<br />**并发编程的本质：充分利用CPU的资源**
- **并发的动机**：在计算能力恒定的情况下处理更多的任务, 处理多任务的能力就是并发能力。
- **并行的动机**：用更多的CPU核心更快地完成任务。
**并发编程的目标是：充分的利用处理器的每一个核，以达到最高的处理性能。**
<a name="OHMYI"></a>
## 线程的状态 
Java的线程有6种状态：可以分析源码：
```java
public enum State {
    //新生状态：线程刚创建
    NEW,
    //运行状态：在JVM中正在运行的线程
    RUNNABLE,
    //阻塞状态：线程处于阻塞状态，等待监视锁，可以重新进行同步代码块中执行
    BLOCKED,
    //等待状态
    WAITING,
    //超时等待：调用sleep() join() wait()方法可能导致线程处于等待状态
    TIMED_WAITING,
    //终止状态：线程执行完毕，已经退出
    TERMINATED;
}

wait/sleep的区别

• 来自不同的类
  • sleep来自Thread类，wait来自Object类。
  • sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。
• 有没有释放锁(释放资源)
  • sleep方法没有释放锁；而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
  • sleep方法是线程被调用时，占着cpu去睡觉，其他线程不能占用cpu，os认为该线程正在工作，不会让出系统资源；wait是进入等待池等待，让出系统资源，其他线程可以占用cpu。

• 使用范围不同

  • wait、notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。

    synchronized(x){
    //或者wait()
    x.notify()
    }

• 是否需要捕获异常

  • sleep必须捕获异常，而wait、notify和notifyAll不需要捕获异常。

    3、Lock锁

    传统的 synchronized ```java /* 题目：三个售票员 卖出 30张票

多线程编程的企业级开发： 1.线程就是一个单独的资源类，没有任何附属的操作！

1. 在高内聚低耦合的前提下， 线程操作(对外暴露的调用方法)资源类 */ public class SaleTicketTest1 { public static void main(String[] args) throws Exception { // main一切程序的入口

    //并发：多线程操作同一个资源， 把资源类丢入线程
    Ticket ticket = new Ticket();
    new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 1; i <=40; i++) {
                ticket.saleTicket();
            }
        }
    }, "A").start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 1; i <=40; i++) {
                ticket.saleTicket();
            }
        }
    }, "B").start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 1; i <=40; i++) {
                ticket.saleTicket();
            }
        }
    }, "C").start();

   } }

class Ticket{ // 资源类 private int number = 30;

//买票方式
//synchronized本质：队列、锁
public synchronized void saleTicket(){
    if (number>0){
        System.out.println(Thread.currentThread().getName() + "卖出第 " +
                           (number--) + "票,还剩下:"+number);
    }
}

}

**使用 juc.locks 包下的类操作 Lock 锁 + Lambda 表达式**<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/23201102/1653367680565-5033ad8a-0cfd-420a-9bb6-0f82df92f727.png#clientId=u3f12988f-c5a8-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=406&id=u36c86bdf&margin=%5Bobject%20Object%5D&name=image.png&originHeight=812&originWidth=1244&originalType=binary&ratio=1&rotation=0&showTitle=false&size=154418&status=done&style=none&taskId=u5c362751-1d83-459c-94ff-73ca69c762e&title=&width=622)
```java
public class SaleTicketTest2 {
    public static void main(String[] args) throws Exception { // main一切程序的入口
        Ticket ticket = new Ticket();
        new Thread(()->{for (int i = 1; i <=40; i++) ticket.saleTicket();},
                   "A").start();
        new Thread(()->{for (int i = 1; i <=40; i++) ticket.saleTicket();},
                   "B").start();
        new Thread(()->{for (int i = 1; i <=40; i++) ticket.saleTicket();},
                   "C").start();
    }
}
/*
lock三部曲：
1.new ReentrantLock();  //new一个锁
2.lock.lock();  //加锁
3.finally => lock.unlock();  //解锁
*/
class Ticket{ // 资源类
    private Lock lock = new ReentrantLock();
    private int number = 30;
    public void saleTicket(){
        //加锁
        lock.lock();
        try {
            //业务代码
            if (number>0){
                System.out.println(Thread.currentThread().getName() + "卖出第" + (number--) + "票,还剩下:"+number);
            }
         } catch (Exception e) {
            e.printStackTrace();
         } finally {
            lock.unlock();
         }
    }
}

synchronized 和 lock 区别：

• synchronized是java的内置关键字；在jvm层面，Lock是个java类；
• synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
• synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)；Lock需在finally中手动释放锁（unlock()方法释放锁），否则容易造成线程死锁；
• 用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2则等待，如果线程1阻塞，线程2则会一直等待下去；而Lock锁不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
• synchronized的锁可重入、不可中断、非公平；而Lock锁可重入、可判断锁、可公平（两者皆可，可自己设置）。
• Lock锁适合大量同步的代码的同步问题；synchronized锁适合代码少量的同步问题。

4、生产者和消费者

线程间的通信 , 线程之间要协调和调度

生产者和消费者 synchroinzed 版

package com.kuang;
/**
题目：现在两个线程，可以操作初始值为0的一个变量：实现一个线程对该变量+1，一个线程对该变量-1，
实现交替10次
* 诀窍：
* 1. 高内聚低耦合的前提下，线程操作资源类
* 2. 判断 、干活、通知
*/
public class B {
    public static void main(String[] args) throws Exception {
        Data data = new Data();
        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}
class Data{ // 资源类
    private int number = 0;
    public synchronized void increment() throws InterruptedException {
        // 判断该不该这个线程做
        if (number!=0){
            this.wait();
        }
        // 干活
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        // 通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        // 判断该不该这个线程做
        if (number==0){
            this.wait(); 
        }
        // 干活
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        // 通知
        this.notifyAll();
    }
}

问题升级：防止虚假唤醒，4个线程，两个加、两个减
解决虚假唤醒问题：if改成while
【重点】if 和 while

package com.kuang;
/**
* 题目：现在四个线程，可以操作初始值为0的一个变量
* 实现两个线程对该变量 + 1，两个线程对该变量 -1
* 实现交替10次
*
* 诀窍：
* 1. 高内聚低耦合的前提下，线程操作资源类
* 2. 判断 、干活、通知
* 3. 多线程交互中，必须要防止多线程的虚假唤醒，也即（判断不能用if，只能用while）
*/
public class B {
    public static void main(String[] args) throws Exception {
        Data data = new Data();
        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
class Data{ // 资源类
    private int number = 0;
    public synchronized void increment() throws InterruptedException {
        // 判断该不该这个线程做
        while (number!=0){
            this.wait();
        }
        // 干活
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        // 通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        // 判断该不该这个线程做
        while (number==0){
            this.wait();
        }
        // 干活
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        // 通知
        this.notifyAll();
    }
}

JUC版生产者和消费者写法

代码测试：

package com.kuang;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 题目：现在四个线程，可以操作初始值为0的一个变量
* 实现两个线程对该变量 + 1，两个线程对该变量 -1
* 实现交替10次
* <p>
* 诀窍：
* 1. 高内聚低耦合的前提下，线程操作资源类
* 2. 判断 、干活、通知
* 3. 多线程交互中，必须要防止多线程的虚假唤醒，也即（判断不能用if，只能用while）
*/
public class B {
    public static void main(String[] args) throws Exception {
        Data data = new Data();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    data.incremen t();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }
}
class Data { // 资源类
    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            // 判断该不该这个线程做
            while (number != 0) {
                condition.await();
            }
            // 干活
            number++;
            System.out.println(Thread.currentThread().getName() + "\t" +
                               number);
            // 通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            // 判断该不该这个线程做
            while (number == 0) {
                condition.await();
            }
            // 干活
            number--;
            System.out.println(Thread.currentThread().getName() + "\t" +
                               number);
            // 通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

问题：随机，需要有序执行。
Condition实现精准通知唤醒
精确通知顺序访问

package com.kuang;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 题目：多线程之间按顺序调用，实现 A->B->C
* 三个线程启动，要求如下：
* AA 打印5次，BB 打印10次，CC 打印15次，依次循环
*
* 重点：标志位
*/
public class C {
    public static void main(String[] args) {
        Resources resources = new Resources();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                resources.print5();
            }
        },"AA").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                resources.print10();
            }
        },"BB").start();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                resources.print15();
            }
        },"CC").start();
    }
}
class Resources{ // 资源类
    private int number = 1; // 1A 2B 3C
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    public void print5(){
        lock.lock();
        try {
            // 判断
            while (number!=1){
                condition1.await();
            }
            // 干活
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName()+'\t'+i);
            }
            // 通知,指定的干活！
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print10(){
        lock.lock();
        try {
            // 判断
            while (number!=2){
                condition2.await();
            }
            // 干活
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName()+'\t'+i);
            }
            // 通知,指定的干活！
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print15(){
        lock.lock();
        try {
            // 判断
            while (number!=3){
                condition3.await();
            }
            // 干活
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName()+'\t'+i);
            }
            // 通知,指定的干活！
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

5、8锁的现象

8锁：就是关于锁的8个问题
1、标准访问，请问先打印邮件还是短信？

package com.kuang;
/**
* 多线程的8锁
* 1、标准访问，请问先打印邮件还是短信？
*/
public class Lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        Thread.sleep(200);
        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Phone{
    public synchronized void sendEmail() throws Exception{
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("sendSMS");
    }
}

结论：被synchronized修饰的方法，锁的对象是方法的调用者。
因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行。

2、邮件方法暂停4秒钟，请问先打印邮件还是短信？

package com.kuang;
import java.util.concurrent.TimeUnit;
/**
* 多线程的8锁
* 1、标准访问，请问先打印邮件还是短信？
* 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
*/
public class Lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        Thread.sleep(200);
        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Phone{
    public synchronized void sendEmail() throws Exception{
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("sendSMS");
    }
}

结论：被synchronized修饰的方法，锁的对象是方法的调用者。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行，第二个方法只有在第一个方法执行完释放锁之后才能执行。

3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？

package com.kuang;
import java.util.concurrent.TimeUnit;
/**
* 多线程的8锁
* 1、标准访问，请问先打印邮件还是短信？
* 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
* 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？
*/
public class Lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        Thread.sleep(200);
        new Thread(()->{
            try {
                // phone.sendSMS();
                phone.hello();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Phone{
    public synchronized void sendEmail() throws Exception{
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("sendSMS");
    }
    public void hello(){
        System.out.println("Hello");
    }
}

结论：新增的方法没有被synchronized修饰，不是同步方法，不受锁的影响，所以不需要等待。其他线程共用了一把锁，所以还需要等待。

4、两部手机、请问先打印邮件还是短信？

package com.kuang;
import java.util.concurrent.TimeUnit;
/**
* 多线程的8锁
* 1、标准访问，请问先打印邮件还是短信？
* 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
* 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？
* 4、两部手机、请问先打印邮件还是短信？
*/
public class Lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        Thread.sleep(200);
        new Thread(()->{
            try {
                // phone.sendSMS();
                // phone.hello();
                phone2.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Phone{
    public synchronized void sendEmail() throws Exception{
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("sendSMS");
    }
}

结论：被synchronized修饰的方法，锁的对象是方法的调用者。因为用了两个对象调用各自的方法，所以两个方法的调用者不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？

package com.kuang;
import java.util.concurrent.TimeUnit;
/**
* 多线程的8锁
* 1、标准访问，请问先打印邮件还是短信？
* 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
* 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？
* 4、两部手机、请问先打印邮件还是短信？
* 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？
*/
public class Lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        Thread.sleep(200);
        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Phone{
    public static synchronized void sendEmail() throws Exception{
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public static synchronized void sendSMS() throws Exception{
        System.out.println("sendSMS");
    }
}

结论：被synchronized和static修饰的方法，锁的对象是类的class对象。因为两个同步方法都被static修饰了，所以两个方法用的是同一个锁，后调用的方法需要等待先调用的方法。

6、两个静态同步方法，2部手机，请问先打印邮件还是短信？

package com.kuang;
import java.util.concurrent.TimeUnit;
/**
* 多线程的8锁
* 1、标准访问，请问先打印邮件还是短信？
* 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
* 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？
* 4、两部手机、请问先打印邮件还是短信？
* 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？
* 6、两个静态同步方法，2部手机，请问先打印邮件还是短信？
*/
public class Lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        Thread.sleep(200);
        new Thread(()->{
            try {
                phone2.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Phone{
    public static synchronized void sendEmail() throws Exception{
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public static synchronized void sendSMS() throws Exception{
        System.out.println("sendSMS");
    }
}

结论：被synchronized和static修饰的方法，锁的对象是类的class对象。因为两个同步方法都被static修饰了，即便用了两个不同的对象调用方法，两个方法用的还是同一个锁，后调用的方法需要等待先调用的方法

7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？

package com.kuang;
import java.util.concurrent.TimeUnit;
/**
* 多线程的8锁
* 1、标准访问，请问先打印邮件还是短信？
* 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
* 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？
* 4、两部手机、请问先打印邮件还是短信？
* 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？
* 6、两个静态同步方法，2部手机，请问先打印邮件还是短信？
* 7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？
*/
public class Lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        Thread.sleep(200);
        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Phone{
    public static synchronized void sendEmail() throws Exception{
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("sendSMS");
    }
}

结论：被synchronized和static修饰的方法，锁的对象是类的class对象。仅仅被synchronized修饰的方法，锁的对象是方法的调用者。因为两个方法锁的对象不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

8、一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？

package com.kuang;
import java.util.concurrent.TimeUnit;
/**
* 多线程的8锁
* 1、标准访问，请问先打印邮件还是短信？
* 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
* 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？
* 4、两部手机、请问先打印邮件还是短信？
* 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？
* 6、两个静态同步方法，2部手机，请问先打印邮件还是短信？
* 7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？
* 8、一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？
*/
public class Lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        Thread.sleep(200);
        new Thread(()->{
            try {
                phone2.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
class Phone{
    public static synchronized void sendEmail() throws Exception{
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("sendSMS");
    }
}

结论：被synchronized和static修饰的方法，锁的对象是类的class对象。仅仅被synchronized修饰的方法，锁的对象是方法的调用者。即便是用同一个对象调用两个方法，锁的对象也不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

小结：
new this 具体的一个手机
static class 唯一的一个模板
一个对象里面如果有多个synchronized方法，某个时刻内，只要一个线程去调用其中一个synchronized方法了，其他的线程都要等待。换句话说，在某个时刻内，只能有唯一一个线程去访问这些synchronized方法，锁的是当前对象this，被锁定后，其他的线程都不能进入到当前对象的其他的synchronized方法。
加个普通方法后发现和同步锁无关，换成两个对象后，不是同一把锁，情况立刻变化。
都换成静态同步方法后，情况又变化了。所有的非静态的同步方法用的都是同一把锁—实例对象本身
synchronized实现同步的基础：java中的每一个对象都可以作为锁
具体的表现为以下三种形式：

• 对于普通同步方法，锁的是当前实例对象
• 对于静态同步方法，锁的是当前的Class对象。
• 对于同步方法块，锁的是synchronized括号里面的配置对象

当一个线程试图访问同步代码块时，首先必须得到锁，退出或抛出异常时必须释放锁，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可以是别的实例对象非静态同步方法。因为跟该实例对象的非静态同步方法用的是不同的锁，所以必须等待该实例对象已经获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
所有的静态同步方法用的也是同一把锁—类对象本身
这两把锁的是两个不同的对象，所以静态的同步方法与非静态的同步方法之间是不会有竞争条件的，但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不论是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要他们用的是同一个类的实例对象。

6、集合类不安全

list 不安全

单线程下：

package com.kuang;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
// 单线程十分安全
public class UnSafeList {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a","b","c");
        list.forEach(System.out::println);
    }
}

多线程下：
并发下ArrayList是不安全的

package com.kuang;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
public class UnSafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // 对比3个线程 和 30个线程，看区别
        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

解决方案：

• Vector默认是安全的：List<String> list = new Vector<>();
• 使用Collections工具类转换成安全的：List<String> list = Collections.synchronizedList(new ArrayList<>());
• JUC包下的CopyOnWriteArrayList：List<String> list = new CopyOnWriteArrayList<>();\
  • CopyOnWrite 写入时复制，简称COW，是计算机程序设计领域的一种优化策略
  • 多个线程调用的时候，list读取的时候是固定的，写入（覆盖），在写入的时候避免覆盖，造成数据问题

package com.kuang;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* 1 故障现象：ConcurrentModificationException
* 2 导致原因：add 方法没有加锁
* 3 解决方案：换一个集合类
* 1、List<String> list = new Vector<>(); JDK1.0 就存在了！
* 2、List<String> list = Collections.synchronizedList(new ArrayList<>
());
* 3、List<String> list = new CopyOnWriteArrayList<>();
*/
public class UnSafeList {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

写入时复制（CopyOnWrite）思想
写入时复制（CopyOnWrite，简称COW）思想是计算机程序设计领域中的一种优化策略。
其核心思想是：如果有多个调用者（Callers）同时要求相同的资源（如内存或是磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者视图修改资源内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的调用者都是透明的（transparently）。
此做法主要的优点是：如果调用者没有修改资源，就不会有副本（private copy）被创建，因此多个调用者只是读取操作时可以共享同一份资源。
读写分离，写时复制出一个新的数组，完成插入、修改或者移除操作后将新数组赋值给array

CopyOnWriteArrayList为什么并发安全且性能比Vector好：
Vector是增删改查方法都加了synchronized，保证同步，但是每个方法执行的时候都要去获得锁，性能就会大大下降，而CopyOnWriteArrayList 只是在增删改上加锁，但是读不加锁，在读方面的性能就好于Vector，CopyOnWriteArrayList支持读多写少的并发情况。

set 不安全

同理

package com.kuang;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
/**
* 1 故障现象：ConcurrentModificationException
* 2 导致原因：add 方法没有加锁
* 3 解决方案：换一个集合类
* 1、Set<String> set = new HashSet<>(); 默认
* 2、Set<String> set = Collections.synchronizedSet(new HashSet<>());
* 3、Set<String> set = new CopyOnWriteArraySet();
* 4 优化建议：（同样的错误，不出现第2次）
*
*/
public class UnSafeList {
    public static void main(String[] args) {
        Set<String> set = new CopyOnWriteArraySet();
        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

hashset底层就是hashMap

Set<String> set = new HashSet<>();
// 点进去
public HashSet() {
    map = new HashMap<>();
}
// add方法 就是map的put方法
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
//private static final Object PRESENT = new Object(); 不变的值

map 不安全

hashMap底层是：数组+链表+红黑树

Map<String,String> map = new HashMap<>();
// 等价于 -- 默认参数 初始容量：16 加载因子：0.75
Map<String,String> map = new HashMap<>(16,0.75); 
// 工作中，常常会自己根据业务来写参数，提高效率

map不安全测试：

public static void main(String[] args) {
    Map<String,String> map = new HashMap<>();
    // 人生如程序，不是选择就是循环，时常的自我总结十分的重要
    for (int i = 1; i <= 30; i++) {
        new Thread(()->{
            map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().subst
                    ring(0,8));
            System.out.println(map);
        },String.valueOf(i)).start();
    }
}

注意名字：Map<String,String> map = new ConcurrentHashMap<>();

public class UnSafeList {
    public static void main(String[] args) {
        // Map<String,String> map = new HashMap<>();
        Map<String,String> map = new ConcurrentHashMap<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().subst
                        ring(0,8));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

深入浅出ConcurrentHashMap详解

7、Callable

多线程中，第3种获得多线程的方式： Callable。
Callable接口类似于Runnable，因为它们都是为其实例可能由另一个线程执行的类设计的。Callable有返回值，会抛出异常，而Runnable不返回结果，也不会抛出异常。
它与Runnable有什么区别呢？

• 是否有返回值
• 是否抛异常
• 方法不一样：一个是call()方法，一个是run()方法。

  基础入门

  ```java package com.kuang;

import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask;

public class CallableDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { MyThread myThread = new MyThread(); FutureTask futureTask = new FutureTask(myThread); // 适配类

    Thread t1 = new Thread(futureTask,"A"); // 调用执行
    t1.start();
    Integer result = (Integer) futureTask.get(); // 获取返回值
    System.out.println(result);
}

}

class MyThread implements Callable{ @Override public Integer call() throws Exception { System.out.println(“call 被调用”); return 1024; } }

![image.png](https://cdn.nlark.com/yuque/0/2022/png/23201102/1653572408781-02c7f246-532a-4e0f-b649-4799c2ea0469.png#clientId=uff97ce76-b7f8-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=348&id=u619f9bcc&margin=%5Bobject%20Object%5D&name=image.png&originHeight=464&originWidth=907&originalType=binary&ratio=1&rotation=0&showTitle=false&size=237055&status=done&style=none&taskId=u1226a74b-6af3-4585-9038-b75ac973dd2&title=&width=680)
<a name="RAJGf"></a>
## Callable 细节 
练武不练功，到头一场空，天下武功没有高低之分，只有习武的人有强弱之别
```java
package com.kuang;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
/**
* 1、get 方法获得返回结果! 一般放在最后一行！否则可能会阻塞
*/
public class CallableDemo {
    public static void main(String[] args) throws ExecutionException,
    InterruptedException {
        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask(myThread); // 适配类
        new Thread(futureTask,"A").start(); // 调用执行
        new Thread(futureTask,"B").start(); // 第二次调用执行，会有结果缓存，不用再次计算
        System.out.println(Thread.currentThread().getName()+" OK");
        Integer result = (Integer) futureTask.get(); // 获取返回值
        System.out.println(result);
    }
}
class MyThread implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("call 被调用");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1024;
    }
}

8、常用辅助类

8.1 CountDownLatch

减法计数器
CountDownLatch允许一个或者多个线程去等待其他线程完成操作。
CountDownLatch接收一个int型参数，表示要等待的工作线程的个数。当然也不一定是多线程，在单线程中可以用这个int型参数表示多个操作步骤。

方法：
CountDownLatch 提供了一些方法：

• await()：使当前线程进入同步队列进行等待，直到latch的值被减到0或者当前线程被中断，当前线程就会被唤醒。
• await(long timeout, TimeUnit unit)：带超时时间的await()。
• countDown()：使latch的值减1，如果减到了0，则会唤醒所有等待在这个latch上的线程。
• getCount()：获得latch的数值。

CountDownLatch详解

package com.kuang;
import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 计数器
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"Start");
                countDownLatch.countDown(); // 计数器-1
            },String.valueOf(i)).start();
         }
         //阻塞等待计数器归零
         countDownLatch.await();
         System.out.println(Thread.currentThread().getName()+" End");
    }
    /**
        顺序不一定，结果诡异，达不到预期的最后End
    */
    public void test1(){
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"Start");
            },String.valueOf(i)).start();
        }
        System.out.println(Thread.currentThread().getName()+" End");
    }
}

原理：

• CountDownLatch 主要有两个方法：
  • countDownLatch.countDown(); 数量减1；
  • countDownLatch.await(); 等待计数器归零，然后再向下执行；
• 当一个或多个线程调用 await 方法时，这些线程会阻塞
• 其他线程调用CountDown方法会将计数器减1（调用CountDown方法的线程不会阻塞）
• 每次有线程调用countDown()方法时数量减1，当计数器变为0时，await() 方法阻塞的线程会被唤醒，继续执行

  8.2 CyclicBarrier

  加法计数器
  现实生活中我们经常会遇到这样的情景，在进行某个活动前需要等待人全部都齐了才开始。例如吃饭时要等全家人都上座了才动筷子，旅游时要等全部人都到齐了才出发，比赛时要等运动员都上场后才开始。
  在JUC包中为我们提供了一个同步工具类能够很好的模拟这类场景，它就是CyclicBarrier类。利用CyclicBarrier类可以实现一组线程相互等待，当所有线程都到达某个屏障点后再进行后续的操作。
  作用：和上面的减法相反，这里是加法，好比集齐7个龙珠召唤神龙，或者人到齐了再开会！

实例：

package com.kuang;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        // CyclicBarrier(int parties, Runnable barrierAction)
        //召唤龙珠的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功");
        });
        for (int i = 1; i <= 7; i++) {
            final int tempInt = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集了第"+ tempInt +"颗龙珠");
                try {
                    cyclicBarrier.await(); // 等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}