JUC基础

学徒易大师

已于 2022-03-03 15:43:26 修改

阅读量122

点赞数

文章标签： java golang

于 2021-09-20 09:34:47 首次发布

本文链接：https://blog.csdn.net/pxx1970/article/details/120387923

版权

多线程进阶==>JUC并发编程

1、线程与进程

进程是程序的一次执行过程，是程序在执行过程中的分配和管理资源的基本单位，每个进程都有自己的地址空间。

线程至少有 5 种状态：初始态、执行态、等待态、就绪态、终止态。

线程是CPU调度和分派的基本单位，它可以和同一进程下的其他线程共享全部资源

线程是进程中的一部分，一个进程可以有多个线程，但线程只能存在于一个进程中。

根本区别：进程是操作系统资源调度的基本单位，线程是任务的调度执行的基本单位

并发编程:并发、并行

并发（多线程操作同一资源）

cpu一核，模拟出来多条线程，快速交替

并行（多个人一起行走）

cpu多核，多个线程可以同时执行，线程池

package JVM.Lesson01;

public class Demo02 {
    public static void main(String[] args) {
        //获取cpu的核数
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用cpu的资源

线程有几个状态

 
    public enum State {
       //新生
        NEW,

        //运行
        RUNNABLE,

        //阻塞
        BLOCKED,
		//等待，死等
        WAITING,

        //超时等待
        TIMED_WAITING,

       //终止
        TERMINATED;
    }

wait和sleep区别

1.来自不同的类

wait–>object

sleep–>Thread

2.关于锁的释放

wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放！

3.适用的范围是不同的

wait：必须在同步代码块中

sleep：可以在任何地方

2、LOCK锁（重点）

传统：synchronized

package pxx.JUC.Demo01;
//模拟卖票
public class Demo01 {
    public static void main(String[] args) {
        ticket ticket = new ticket();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}

class ticket{
    //票数
    private int num=30;
    //卖票的方式
    //synchronized :本质：队列，锁
    public synchronized void sale(){
        if (num>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(num--)+"票"+"还剩余"+num);
        }
    }
}

LOCK锁

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3dabuPwa-1632100950479)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210916202326140.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pSqkvauK-1632100950486)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210916202644833.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qXpLsWiO-1632100950492)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210916202920540.png)]$

公平锁：十分公平，可以先来后到

非公平锁：十分不公平：可以插队（默认）

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//LOCk锁 、卖票
public class Demo02 {
    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();
        new Thread(()->{for (int i = 0; i < 40; i++)ticket.sale();},"A").start();
        
        new Thread(()->{ for (int i = 0; i < 40; i++) ticket.sale();},"B").start();
        
        new Thread(()->{for (int i = 0; i < 40; i++) ticket.sale();},"C").start();
    }
}
//LOCk三部曲
//1.new ReentrantLock
//2.lock.lock(); //加锁
//3.finally---lock.unlock(); //解锁
class Ticket2{
    //票数
    private int num=30;
    Lock lock=new ReentrantLock();

    public  void sale(){
        lock.lock();//加锁
        try {
            //业务代码
            if (num>0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+(num--)+"票"+"还剩余"+num);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Synchronized和LOCK区别

1.Synchronized 内置的java关键字，Lock是一个java类

2.Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁

3.Synchronized 和自动释放锁，Lock必须手动释放锁！如果不释放锁，死锁

4.Synchronized 线程1（获得锁，阻塞）线程2（等待，傻傻的等）；Lock锁就不会一直等待下去

5.Synchronized 可重入锁，不可以中断，非公平；Lock，可重入锁，可以判断锁，非公平（可以自己设置）

6.Synchronized 适合所少量的代码同步问题，Lock适合锁大量的同步代码！

锁是什么？如何判断锁的是谁？

3、生产者和消费者问题

面试：单例模式、排序算法、生产者和消费者、死锁

生产者和消费者问题Synchronized 版

package pxx.JUC.Demo02;
/**
 * 线程之间的通信问题，生产者和消费者问题!
 * 线程交替执行  A  B操作同一个变量   num=0
 * A num+1
 * B mun-1
 */
public class A {
    public static void main(String[] args) {
        B b = new B();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    b.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    b.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

    }
}
class B{
    private int num=0;
    public synchronized void increment() throws InterruptedException {
        if (num!=0){
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"---"+num);
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        if (num==0){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"---"+num);
        this.notifyAll();
    }
}

问题存在：A，B,C,D四个线程还安全吗？

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6eilhHZ8-1632100950500)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210916211408655.png)]$

如何解决：if改为while判断

package pxx.JUC.Demo02;
/*线程之间的通信问题，生产者和消费者问题! 
* 线程交替执行  A  B操作同一个变量   num=0 
* A num+1 
* B mun-1 */
public class A {
    public static void main(String[] args) {
            B b = new B();
            new Thread(()->{            
             for (int i = 0; i < 10; i++) {                
               try {                    
               b.increment();                
               } catch (InterruptedException e) {
                  e.printStackTrace();           
                       }        
                   }    
               },"A").start();        
           new Thread(()->{            
             for (int i = 0; i < 10; i++) {                
               try {                    
               b.increment();                
               } catch (InterruptedException e) {
                  e.printStackTrace();           
                       }        
                   }    
               },"B").start();
           new Thread(()->{            
             for (int i = 0; i < 10; i++) {                
               try {                    
               b.increment();                
               } catch (InterruptedException e) {
                  e.printStackTrace();           
                       }        
                   }    
               },"C").start();
           new Thread(()->{            
             for (int i = 0; i < 10; i++) {                
               try {                    
               b.increment();                
               } catch (InterruptedException e) {
                  e.printStackTrace();           
                       }        
                   }    
               },"D").start();   
class B{
    private int num=0;    
    public synchronized void increment() throws InterruptedException {    
        while (num!=0){        
            this.wait();    
        }        
        num++;       
        System.out.println(Thread.currentThread().getName()+"---"+num);        
        this.notifyAll();  
    }
    public synchronized void decrement() throws InterruptedException {   
       while (num==0){       
            this.wait();     
       }        
       num--;        
       System.out.println(Thread.currentThread().getName()+"---"+num);        
       this.notifyAll();    
    }
}

JUC版的生产者和消费者问题/Lock

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4mK4rcK3-1632100950507)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210916215624360.png)]$

通过Lock找到Condition

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RyacAqnz-1632100950509)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210916215052609.png)]$

package pxx.JUC.Demo02;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程之间的通信问题，生产者和消费者问题!
 * 线程交替执行  A  B操作同一个变量   num=0
 * A num+1
 * B mun-1
 */
public class G {
    public static void main(String[] args) {
        H h = new H();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    h.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    h.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    h.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    h.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
class H{
    private int num=0;
    Lock lock = new ReentrantLock();
    Condition condition=lock.newCondition();
    public  void increment() throws InterruptedException {
        lock.lock();
        try {
            while (num!=0){
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName()+"---"+num);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public  void decrement() throws InterruptedException {
        lock.lock();
        try {

            while (num==0){
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"---"+num);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
}
}

Condition:精准的通知和唤醒线程

代码实现

package pxx.JUC.Demo02;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * A执行完调用B，B执行完调用C，C执行完调用A
 */
public class Test {
    public static void main(String[] args) {
        Go go = new Go();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                go.An1();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                go.An2();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                go.An3();
            }
        },"C").start();

    }
}

class Go{
    private int num=1;//  1 An1执行 2 An2执行 3 An3执行
    private Lock lock=new ReentrantLock();
    private Condition condition1=lock.newCondition();
    private Condition condition2=lock.newCondition();
    private Condition condition3=lock.newCondition();
    public void An1(){
        lock.lock();
        try {
          while (num!=1){
              condition1.await();
              System.out.println(Thread.currentThread().getName()+"---AAAAA");
            }
            num=2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void An2(){
        lock.lock();
        try {
            while (num!=2){
                condition2.await();
                System.out.println(Thread.currentThread().getName()+"---BBBBB");
            }
            num=3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void An3(){
        lock.lock();
        try {
            while (num!=3){
                condition3.await();
                System.out.println(Thread.currentThread().getName()+"---CCCCC");
            }
            num=1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

4、8锁现象

如何判断锁的是谁？

对象、Class

package pxx.JUC.Lock8;import java.util.concurrent.TimeUnit;/** * 8锁，就是关于锁的8个问题 * 1.标准情况下，两个线程先执行发短信还是打电话？ 、、先发短信后打电话 * 2.Send延迟四秒，两个线程先执行发短信还是打电话？ 、、先发短信后打电话 */public class Test1 {    public static void main(String[] args) {        Phone phone = new Phone();        new Thread(()->{            phone.Send();        }).start();        new Thread(()->{            phone.Call();        }).start();    }}class Phone{    //synchronized  锁的对象是方法的调用者！    //两个方法用的同一个锁，谁先拿到谁先执行。    public synchronized void Send(){        try {            TimeUnit.SECONDS.sleep(4);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("发短信");    }    public synchronized void Call(){        System.out.println("打电话");    }}

package pxx.JUC.Lock8;import java.util.concurrent.TimeUnit;/** * 3.增加了一个普通方法，先执行hello还是发短信  、、先执行hello * 4.两个对象，两个同步方法， 先执行发短信还是打电话 、、先执行打电话 */public class Test2 {    public static void main(String[] args) {        Phone2 phone = new Phone2();        Phone2 phone1=new Phone2();        new Thread(()->{            phone.Send();            try {                TimeUnit.SECONDS.sleep(1);            } catch (InterruptedException e) {                e.printStackTrace();            }        }).start();        new Thread(()->{            phone1.Call();        }).start();    }}class Phone2{    //synchronized  锁的对象是方法的调用者！    //两个方法用的同一个锁，谁先拿到谁先执行。    public synchronized void Send(){        try {            TimeUnit.SECONDS.sleep(4);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("发短信");    }    public synchronized void Call(){        System.out.println("打电话");    }    //普通方法，没有锁，不用等待。    public void Hello(){        System.out.println("hello");    }}

package pxx.JUC.Lock8;import java.util.concurrent.TimeUnit;/** * 5.两个静态同步方法，只有一个对象，先执行打电话还是发短信？ 、、先执行发短信 * 6.两个静态同步方法，有两个对象，先执行打电话还是发短信？ 、、先执行发短信 */public class Test3{    public static void main(String[] args) {        Phone3 phone = new Phone3();        Phone3 phone1 = new Phone3();        new Thread(()->{            phone.Send();            try {                TimeUnit.SECONDS.sleep(1);            } catch (InterruptedException e) {                e.printStackTrace();            }        }).start();        new Thread(()->{            phone1.Call();        }).start();    }}class Phone3{    //synchronized  锁的对象是方法的调用者！    //static 静态方法    //类一加载就有了， 说的是Class    public static synchronized void Send(){        try {            TimeUnit.SECONDS.sleep(4);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("发短信");    }    public static synchronized void Call(){        System.out.println("打电话");    }}

package pxx.JUC.Lock8;import java.util.concurrent.TimeUnit;/** * 7. 1个静态同步方法，1个普通方法，只有一个对象，先执行打电话还是发短信？ 、、先执行打电话 * 8.1个静态同步方法，1个普通方法，有两个对象，先执行打电话还是发短信？ 、、先执行打电话 */public class Test4 {    public static void main(String[] args) {        Phone4 phone = new Phone4();        Phone4 phone1 = new Phone4();        new Thread(()->{            phone.Send();            try {                TimeUnit.SECONDS.sleep(1);            } catch (InterruptedException e) {                e.printStackTrace();            }        }).start();        new Thread(()->{            phone1.Call();        }).start();    }}class Phone4{    //静态同步方法   锁的是Class    public static synchronized void Send(){        try {            TimeUnit.SECONDS.sleep(4);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("发短信");    }    //普通同步方法  锁的是方法的调用者    public  synchronized void Call(){        System.out.println("打电话");    }}

小结

new this 具体的一个Phone

static Class唯一的一个模板

5、集合类不安全

List不安全

package pxx.JUC.ListUnSafe;import java.util.*;import java.util.concurrent.CopyOnWriteArrayList;// java.util.ConcurrentModificationException 并发修改异常！public class ListTest {    public static void main(String[] args) {        //并发下ArrayList不安全        /*        *解决方案：        * 1.Vector<String> list = new Vector<>();        * 2.List<String> list = Collections.synchronizedList(new ArrayList<>());        * 3. List<String> list = new CopyOnWriteArrayList<>();       */        //copyOnWrite 写入时复制  COW 计算机程序设计领域的一种优化策略        //多个线程调用的时候，list，读取的时候，固定的，写入（覆盖）        // 写入的时候避免覆盖，造成数据问题！        //读写分离        List<String> list = new CopyOnWriteArrayList<>();        for (int i = 0; i < 10; i++) {            new Thread(()->{                list.add(UUID.randomUUID().toString().substring(0,5));                System.out.println(list);            },String.valueOf(i)).start();        }    }}

Set:不安全

package pxx.JUC.ListUnSafe;import java.util.Collections;import java.util.HashSet;import java.util.Set;import java.util.UUID;import java.util.concurrent.CopyOnWriteArraySet;//java.util.ConcurrentModificationException  并发修改异常public class SetTest {    public static void main(String[] args) {        /**         *  Set<String> set=new HashSet<>();         *  如何修改         * 1. Set<String> set= Collections.synchronizedSet(new HashSet<>());         * 2.Set<String> set=new CopyOnWriteArraySet<>();         */        Set<String> set=new CopyOnWriteArraySet<>();        for (int i = 0; i < 20; i++) {            new Thread(()->{              set.add(UUID.randomUUID().toString().substring(0,5));                System.out.println(set);            },String.valueOf(i)).start();        }    }}

hashSet的底层是什么？

 public HashSet() {        map = new HashMap<>();    }//add  set本质就是map  key是无法重复的！ public boolean add(E e){     retyrn map.put(e.PRESENT)==null; }private static final Object PRESENT=new Object();//不变的值

Map:不安全

重要

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MaQjjiZN-1632100950513)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210917155539670.png)]$

package pxx.JUC.ListUnSafe;import java.util.Collections;import java.util.HashMap;import java.util.Map;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;//java.util.ConcurrentModificationExceptionpublic class MapTest {    public static void main(String[] args) {        /**解决方法         * 1.Map<String,String> map= Collections.synchronizedMap(new HashMap<>());         * 2. Map<String,String> map=new ConcurrentHashMap<>();         * 研究ConcurrentHashMap的原理         */        Map<String,String> map=new HashMap();               for (int i = 0; i < 20; i++) {            new Thread(()->{                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));                System.out.println(map);            },String.valueOf(i)).start();        }    }}

6、Callable

Callable接口类似于Runnable ，因为它们都是为其实例可能由另一个线程执行的类设计的。然而， Runnable不返回结果，也不能抛出被检查的异常。

可以有返回值
可以抛出异常
方法不同，run（）/call（）

package pxx.JUC.ListUnSafe;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/** * new Thread(new Runnable).start(); * new Thread(new FutureTask<v>()).start(); * new Thread(new FutureTask<v>(Callable)).start(); */public class CallableTest {    public static void main(String[] args) throws ExecutionException, InterruptedException {        Mythread thread = new Mythread();        FutureTask futureTask = new FutureTask(thread);        new Thread(futureTask,"A").start();        new Thread(futureTask,"B").start();//结果会被缓存        Integer o = (Integer) futureTask.get();//这个get方法可能会产生阻塞！把他放到最后        //或者使用异步通信来处理        System.out.println(o);    }}class Mythread implements Callable<Integer>{    @Override    public Integer call() throws Exception {        System.out.println("Call");//会打印几个call        return 1024;    }}

细节：

1.有缓存

2.结果可能需要等待，会阻塞！

7、常用的辅助类（必会）

7.1、CountDownLatch

允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

CountDownLatch用给定的计数初始化。 await方法阻塞，直到由于countDown()方法的调用而导致当前计数达到零，之后所有等待线程被释放，并且任何后续的await 调用立即返回。这是一个一次性的现象 - 计数无法重置。

package pxx.JUC.Demo03;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo01 {
    public static void main(String[] args) throws InterruptedException {
        //总数是6，必须要执行任务的时候，在调用
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i =1; i <=6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"go go go");
                countDownLatch.countDown();//数量-1
            },String.valueOf(i)).start();

        }
        countDownLatch.await();//等待计数器为0，然后再往下执行
        System.out.println("close door");
    }
}

原理：

countDownLatch.countDown();//数量-1

countDownLatch.await();//等待计数器为0，然后再往下执行

每次有线程调用countDown()数量-1，加入计数器变为0， countDownLatch.await()就会被唤醒，继续执行

7.2、CyclicBarrier

允许一组线程全部等待彼此达到共同屏障点的同步辅助。循环阻塞在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。屏障被称为循环，因为它可以在等待的线程被释放之后重新使用。

可以看做：加法计数器

package pxx.JUC.Demo03;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
 //集齐七颗龙珠召唤神龙
public class CyclicBarrierDemo01 {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功");
        });
        for (int i =1; i <=7; i++) {
            final int temp=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"龙珠");
                try {
                    cyclicBarrier.await();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

7.3、Semaphore

一个计数信号量。在概念上，信号量维持一组许可证。如果有必要，每个acquire()都会阻塞，直到许可证可用，然后才能使用它。每个release()添加许可证，潜在地释放阻塞获取方。但是，没有使用实际的许可证对象; Semaphore只保留可用数量的计数，并相应地执行。

六个车，抢三个车位。

package pxx.JUC.Demo03;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    public static void main(String[] args) {
        //线程数量
        Semaphore semaphore = new Semaphore(3);
        for (int i =1; i < 7; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();//acquire() 得到
                    System.out.println(Thread.currentThread().getName()+"抢到了车位");
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName()+"离开了车位");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();//release() 释放
                }
            },String.valueOf(i)).start();
        }
    }
}

原理：

semaphore.acquire();获得，假设已经满了，等待到被释放为止

semaphore.release();释放，会将当前的信号量释放+1，然后唤醒等待的线程！

作用：多个共享资源互斥的使用！并发限流，控制最大的线程数！

8.ReadWriteLock

ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。读可以被多个线程同时读，写的时候只能有一个线程去写。

package pxx.JUC.Demo03;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
 *ReadWriteLock
 * 读-读  可以共存
 * 写-写  不能共存
 * 读-写  不能共存
 * 独占锁（写锁）一次只能被一个线程占有
 * 共享锁（读锁）多个线程可以同时占有
 */


public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        //写入
        for (int i =1; i < 7; i++) {
            final int temp=i;
           new Thread(()->{
               myCache.write(temp+"",temp+"");
           },String.valueOf(i)).start();
        }
        //读出
        for (int i =1; i <7; i++) {
            final int temp=i;
            new Thread(()->{
                myCache.read(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
    }
}

//自定义缓存
class MyCache{
    private volatile Map<String,Object> map=new HashMap<>();
    //读写锁，更加细粒度的控制
    ReadWriteLock readWriteLock=new ReentrantReadWriteLock();
    public void write(String key,Object value){
        //写的时候只希望同时只有一个线程写
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"写入了"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入ok"+key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }

    }
    public void read(String key,Object value){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读入了"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"读入ok"+key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }

    }
}

9、阻塞队列

队列：FIFO

不得不阻塞：

写入：如果队列满了，就必须阻塞等待
取：如果队列是空的，必须阻塞等待生产

什么时候我们会使用阻塞队列：多线程并发处理，线程池！

学会使用队列

添加、移除

四组API

方式	抛出异常	有返回值，不会抛出异常	阻塞，等待	超时等待
添加	add()	offer()	put()	offer()
移除	remove()	poll()	take()	poll()
判断对列首	element()	peek()	-	-

抛出异常

package pxx.JUC.BQ;
import java.util.concurrent.ArrayBlockingQueue;

public class Test {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> blo = new ArrayBlockingQueue<>(3);
        System.out.println(blo.add("a"));
        System.out.println(blo.add("b"));
        System.out.println(blo.add("c"));
		System.out.println(blo.element());//判断队首
        //IllegalStateException: Queue full 抛出异常
      //  System.out.println(blo.add("d"));

        System.out.println(blo.remove());
        System.out.println(blo.remove());
        System.out.println(blo.remove());
        
        //NoSuchElementException: 抛出异常
        //System.out.println(blo.remove());
    }
}

不会抛出异常

 //有返回值，不抛出异常    public static void test2(){        ArrayBlockingQueue<String> blo = new ArrayBlockingQueue<>(3);        System.out.println(blo.offer("a"));        System.out.println(blo.offer("b"));        System.out.println(blo.offer("c"));        System.out.println(blo.peek());//判断队首       // System.out.println(blo.offer("d")); false 不抛出异常        System.out.println(blo.poll());        System.out.println(blo.poll());        System.out.println(blo.poll());        System.out.println(blo.poll());//null 不抛出异常    }

阻塞等待

 public static void test3() throws InterruptedException {
        ArrayBlockingQueue<String> blo = new ArrayBlockingQueue<>(3);
        blo.put("a");
        blo.put("b");
        blo.put("c");
       // blo.put("d");//队列没有位置了，一直阻塞
        System.out.println(blo.take());
        System.out.println(blo.take());
        System.out.println(blo.take());
        //System.out.println(blo.take());//没有元素了，一直阻塞

    }

超时等待

public static void test4() throws InterruptedException {
        ArrayBlockingQueue<String> blo = new ArrayBlockingQueue<>(3);
        blo.offer("a");
        blo.offer("b");
        blo.offer("c");
        blo.offer("d",2, TimeUnit.SECONDS);//等待超过2s就退出
        System.out.println(blo.poll());
        System.out.println(blo.poll());
        System.out.println(blo.poll());
        blo.poll(2,TimeUnit.SECONDS);//等待超过2s就退出
    }

 SynchronousQueue同步队列

没有容量，

进去一个元素，必须等待取出来之后，才能再往里面放一个元素！

put，take

package pxx.JUC.BQ;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
/**
 * 同步队列和其他的blockingQueue不一样，
 * SynchronousQueue不存储元素，put了一个元素，必须从里面先take取出来，否则不能再put进去值。
 */
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        SynchronousQueue<String> blockingQueue = new SynchronousQueue<>();
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"put-a");
                blockingQueue.put("a");
                System.out.println(Thread.currentThread().getName()+"put-b");
                blockingQueue.put("b");
                System.out.println(Thread.currentThread().getName()+"put-c");
                blockingQueue.put("c");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T1-").start();
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T2-take-").start();
    }
}

10、线程池（重点）

线程池：三大方法，七大参数，四种拒绝策略。

池化技术

程序的运行，本质：占用系统的资源！优化资源的使用！=>池化技术

线程池、连接池、内存池、对象池、、、创建，销毁，十分浪费资源

池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。

线程池的好处：

降低资源消耗
提高响应的速度
方便管理

线程复用，可以控制最大并发数，管理线程。

线程池三大方法：

package pxx.JUC.Demo04;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * Executors:工具类，三大方法 * 使用了线程池之后，要用线程池来创建对象。 */public class Demo {    public static void main(String[] args) {       // ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程       // ExecutorService threadPool = Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小        ExecutorService  threadPool = Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱。        //线程池用完，程序结束，关闭        try {        for (int i = 0; i < 100; i++) {            threadPool.execute(()->{                System.out.println(Thread.currentThread().getName()+"ok");            });            }        } catch (Exception e) {            e.printStackTrace();        } finally {            threadPool.shutdown();        }    }}

七大参数：

源码分析

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
 public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
//本质ThreadPoolExecutor
     public ThreadPoolExecutor(int corePoolSize,//核心线程池大小
                              int maximumPoolSize,//最大核心线程池大小
                              long keepAliveTime,//超时了没人调用就会释放
                              TimeUnit unit,//超时单位
                              BlockingQueue<Runnable> workQueue,//阻塞队列
                              ThreadFactory threadFactory,//线程工厂，创建线程的，一般不用动
                              RejectedExecutionHandler handler//拒绝策略) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

四种拒绝策略：

/*
* Executor 四种拒绝策略
* new ThreadPoolExecutor.AbortPolicy()//银行满了，还有人进来，不处理这个人的，抛出异常
* new ThreadPoolExecutor.CallerRunsPolicy()//哪来的去哪里.
* new ThreadPoolExecutor.DiscardPolicy()//队列满了，丢掉任务，不会抛出异常
* new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了，尝试和最早的竞争，不会抛出异常
* */

小结和拓展

线程池的大小如何去设置！

了解：IO密集型，CPU密集型：（调优）

package pxx.JUC.Demo04;
import java.util.concurrent.*;
public class Demo01 {
    public static void main(String[] args) {
        //自定义线程池！工作ThreadPoolExecutor
        
        //最大线程池该如何定义
        //1.Cpu密集型，几核就是几，可以保持CPU的效率最高！
        //2.IO密集型: >判断你程序中十分耗IO的线程 大于2倍就行
        ExecutorService threadPool = new ThreadPoolExecutor(2,
                Runtime.getRuntime().availableProcessors(),
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());//银行满了，还有人进来，不处理这个人的，抛出异常 - RejectedExecutionException

        //线程池用完，程序结束，关闭
        try {
            //最大承载：Deque+max

            for (int i =1; i <=10; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }

    }
}

11、四大函数式接口（必须掌握）

新时代的程序员：lambda表达式，链式编程，函数式接口，Stream流式计算

函数式接口:只有一个方法的接口

package pxx.JUC.Function;import java.util.function.Function;//Function:函数式接口：有一个输入参数，有一个输出public class Demo01 {    public static void main(String[] args) {//        Function<String,String> function=new Function<String, String>() {//            @Override//            public String apply(String s) {//                return s;//            }//        };        Function<String,String> function=(string)->{return string;};        System.out.println(function.apply("你好啊"));    }}

Predicate-断定型接口:有一个输入参数，返回值只能是布尔值！

package pxx.JUC.Function;import java.util.function.Predicate;/** * Predicate-断定型接口：有一个输入参数，返回值只能是布尔值！ */public class Demo02 {    public static void main(String[] args) {        //判断字符串是否为空//        Predicate<String> predicate=new Predicate<String>() {//            @Override//            public boolean test(String s) {//                return s.isEmpty();//            }//        };        Predicate<String> predicate=(s)->{return s.isEmpty();};        System.out.println(predicate.test(""));    }}

Consumer 消费型接口：只有输入，内有返回值

package pxx.JUC.Function;import java.util.function.Consumer;/** * Consumer 消费型接口：只有输入，内有返回值 */public class Demo03 {    public static void main(String[] args) {//        Consumer<String> consumer=new Consumer<String>() {//            @Override//            public void accept(String str) {//                System.out.println(str);//            }//        };        Consumer<String> consumer=(str)->{            System.out.println(str);        };        consumer.accept("sad");    }}

Supplier:供给型接口 没有参数 只有返回值。

package pxx.JUC.Function;import java.util.function.Supplier;/** *  Supplier:供给型接口， 没有参数 只有返回值。 */public class Demo04 {    public static void main(String[] args) {//        Supplier<Integer> supplier=new Supplier() {//            @Override//            public Object get() {//                return 1024;//            }//        };        Supplier<Integer> supplier=()->{return 1024;};        System.out.println(supplier.get());    }}

12、Stream流式计算

什么是Stream流式计算

大数据：存储+计算

集合、MySQL本质就是存储东西的；

计算交给流来操作

package pxx.JUC.Stream;import java.util.Arrays;import java.util.List;/** * 题目要求：一分钟完成此题，只能用一行代码实现！ * 现在有5个用户！筛选： * 1.ID 必须是偶数 * 2.年龄必须大于23岁 * 3.用户名转换为大写字母 * 4.用户名字母倒着排序 * 5.只输出一个用户！ */public class Test {    public static void main(String[] args) {        User u1=new User(21,1,"a");        User u2=new User(22,2,"b");        User u3=new User(23,3,"c");        User u4=new User(24,4,"d");        User u5=new User(25,6,"e");        //集合就是存储        List<User> list= Arrays.asList(u1,u2,u3,u4,u5);        //lambda表达式，链式编程，函数式接口，Stream流式计算        list.stream()                .filter(u->{return u.getId()%2==0;})                .filter(u->{return u.getAge()>23;})                .map(u->{return u.getName().toUpperCase();})                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})                .limit(1)                .forEach(System.out::println);    }}

13、ForkJoin

什么是ForkJoin

ForkJoin在JDk1.7，并行执行任务！提高效率。大数据量！

大数据：Map Reduce（把大任务拆分为小任务）

ForkJoin特点：工作窃取

这里面维护的都是双端队列

懵逼了。。。。

14、异步回调

回来再补

15、JMM

请你谈谈你对volatile的理解

volatile是java虚拟机提供的轻量级的同步机制

保证可见性
不保证原子性
禁止指令重排

什么是JMM

JMM：java内存模型，不存在的东西，概念！约定！

关于JMM的一些同步的约定：

线程解锁前:必须把共享变量立刻刷回主存
线程加锁前：必须读取主存的最新值到工作内存中！
加锁和解锁是同一把锁

线程 工作内存、主存

8种操作

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UklOtZY4-1632100950518)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210918165122124.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0uJ9O2L7-1632100950520)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210918165612818.png)]$

关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成：

lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：

如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。但Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
不允许read和load、store和write操作之一单独出现
不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现
如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。

package pxx.JUC.Volatile;

import java.util.concurrent.TimeUnit;

public class Demo01 {
    private static int num=0;
    public static void main(String[] args) {
        new Thread(()->{
            while (num==0){

            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num=1;
        System.out.println(num);
    }
}//程序不会停止运行

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ISZSned2-1632100950523)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210918171048699.png)]$

问题：程序不知道主内存的值已经被修改过了

16、Volatile

1.保证可见性

package pxx.JUC.Volatile;
//保证可见性
import java.util.concurrent.TimeUnit;

public class Demo01 {
    //不加 volatile 程序就会死循环
    //加 volatile 可以保证可见性
    private volatile static int num=0;
    public static void main(String[] args) {
        new Thread(()->{
            while (num==0){

            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num=1;
        System.out.println(num);
    }
}

2.不保证原子性原子性：不可分割线程A在执行任务的时候，不能被打扰的，也不能被分割。要么同时成功、要么同时失败。

package pxx.JUC.Volatile;//不保证原子性public class Demo02 {    //volatile 不保证原子性    private volatile  static int num=0;    public static void add(){      num++;    }    public static void main(String[] args) {        //理论上num结果应该为2万        for (int i = 0; i < 20; i++) {            new Thread(()->{                for (int i1 = 0; i1 < 1000; i1++) {                    add();                }            }).start();        }        while (Thread.activeCount()>2){            Thread.yield();        }        System.out.println(Thread.currentThread().getName()+" "+num);    }}

如果不加Lock或者Synchronized，怎样保证原子性

使用原子类，解决原子性问题

原子类为什么这么高级

package pxx.JUC.Volatile;import java.util.concurrent.atomic.AtomicInteger;//不保证原子性public class Demo02 {    private volatile  static AtomicInteger num=new AtomicInteger();    public static void add(){     num.getAndIncrement();//AtomicInteger +1方法， CAS    }    public static void main(String[] args) {        //理论上num结果应该为2万        for (int i = 0; i < 20; i++) {            new Thread(()->{                for (int i1 = 0; i1 < 1000; i1++) {                    add();                }            }).start();        }        while (Thread.activeCount()>2){            Thread.yield();        }        System.out.println(Thread.currentThread().getName()+" "+num);    }}

这些类的底层都直接和操作系统挂钩！在内存中修改值！Unsafe类是一个很特殊的存在！

指令重排

什么是指令重排：你写的程序，计算机并不是按照你写的那样去执行。

源代码–>编译器优化的重排–>指令并行也可能会重排–>内存系统也会重排–>执行

处理器在进行指令重排的时候，考虑：数据之间的依赖性

int x=1;//1int y=2;//2x=x+5;//3y=x*x;//4我们期望的：1234 但执行的时候可能变成 2134 1324可不可能：4123

可能造成影响的结果:a b x y 默认值都为0

线程A	线程B
x=a	y=b
b=1	a=2

正常的结果：x=0；y=0；但是可能由于指令重排

线程A	线程B
b=1	a=2
x=a	y=b

指令重排导致的诡异结果：x=2;y=1;

Volatile可以避免指令重排：

内存屏障，cpu指令。作用：

保证特定的操作的执行顺序！
可以保证某些变量的内存可见性（利用这些特性Volatile实现了可见性）

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TRmikxuM-1632100950526)(C:\Users\蟹老板\AppData\Roaming\Typora\typora-user-images\image-20210918182323437.png)]$

Volatile是可以保持可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！

17、彻底玩转单例模式

饿汉式 DCL懒汉式，

饿汉式

package pxx.JUC.single;

/**
 *饿汉式单例
 */
public class Hungry {
    //可能会浪费空间
    private byte[] data1=new byte[1024*1024];
    private byte[] data2=new byte[1024*1024];
    private byte[] data3=new byte[1024*1024];
    private byte[] data4=new byte[1024*1024];
    private Hungry(){

    }
    private final static Hungry HUNGRY=new Hungry();
    public static Hungry getInstance(){
        return HUNGRY;
    }
    public static void main(String[] args) {

    }
}

DCL懒汉式

package pxx.JUC.single;

import com.sun.imageio.plugins.common.LZWCompressor;

/**
 * 懒汉式单例
 */
public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private volatile static LazyMan lazyMan;
    //双重检测锁模式 懒汉单例 DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan=new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();
        }
    }
}

18、深入理解CAS

什么是CAS

19、原子引用

20、各种锁的理解

1、公平锁、非公平锁

公平锁：非常公平，不能够插队，必须先来后到

非公平锁：不公平，可以插队（默认都是非公平锁）

2、可重入锁

可重入锁（递归锁）：拿到外边的锁，就可以拿到里面的锁，自动获得。

synchronized版

package pxx.JUC.Lock;

//synchronized
public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.call();
        },"A").start();
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}

class Phone{
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"call");
        send();
    }
    public synchronized void send(){
        System.out.println(Thread.currentThread().getName()+"send");
    }
}

Lock版

package pxx.JUC.Lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//Lock锁
public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.call();
        },"A").start();
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}

class Phone2{
    Lock lock=new ReentrantLock();
    public  void call(){
        lock.lock();//细节问题：lock.lock()和lock.unlock()必须配对，否则就会死在里面
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"call");
            send();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            lock.unlock();
        }

    }
    public  void send(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"send");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}