JUC并发编程

松下的蘑菇

已于 2022-11-22 15:05:43 修改

阅读量208

点赞数

文章标签： java 开发语言 juc

于 2022-11-22 15:05:22 首次发布

本文链接：https://blog.csdn.net/D19992730096/article/details/127983014

版权

JUC并发编程

1、线程和进程

进程线程

进程：一个程序，程序的集合！一个进程往往包含多个线程，至少包含一个！

线程(java)：Thread，Runnable， Callable

并发并行

并发：多个线程操作同一个资源

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

并行：多个线程同时执行

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

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

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

线程有几个状态

pubilc enum State{
    //新生
    NEW,
    //运行
    RUNNABLE,
    //阻塞
    BLOCKED;
    //等待
    WAITING,
    //超时等待
    TIMED_WAITING;
    //终止
    TERMINATED,
}

wait/sleep区别

1、来自不同的类

wait => Objict , sleep => Thread

2.关于锁的释放

wait:会释放锁 sleep:不会释放锁

3.使用的范围是不同的

wait：必须在同步代码块中 sleep：可以再任何地方

4.是否需要捕获异常

wait 不需要捕获异常 sleep：必须要捕获异常

2、Lock锁

传统Synchronized

package com.LOCK;
//基本的买票例子
//真正的多线程开发  降低耦合性
//线程就是一个单独的资源类，没有任何一个附属的操作！
//1、属性  方法
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //并发、多线程操作同一个资源类,把资源丢入线程
        Ticket ticket = new Ticket();

        //@FunctionalInterface 函数式接口，lambda表达式(参数)->{代码}
        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();
    }
}
//资源类 OOP
class Ticket{
    //属性、方法
    private int number = 30;

    //买票的方式
    //synchronized 本质：锁、对列
    public synchronized void sale(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票，剩余："+number);

        }
    }
}

Lock 接口(重点)

没有块结构化锁定会删除使用synchronized方法和语句发生的锁的自动释放。在大多数情况下，应使用以下惯用语：

   Lock l = ...; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); }

**注意:**当在不同范围内发生锁定和解锁时，必须注意确保在锁定时执行的所有代码由try-finally或try-catch保护，以确保在必要时释放锁定。

所有已知实现类：

**ReentrantLock ：**可重入锁（常用）
trantReadWriteLock.ReadLock：（读锁）
ReentrantReadWriteLock.WriteLock：（写锁）

**ReentrantLock **

public ReentrantLock(){sync = new NonfairSync();}//NonfairSync()非公平锁 
public ReentrantLock(boolean fair){ syuc = fair ? newFairSync():NonfairSync();}//newFairSync()公平锁

公平锁：可以来后到

非工平锁：可以插队

4.例题

package com.LOCK;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发、多线程操作同一个资源类,把资源丢入线程
        Ticket2 ticket2 = new Ticket2();
        new Thread(()-> { for (int i = 0; i < 40; i++) ticket2.sale();},"A").start();
        new Thread(()-> { for (int i = 0; i < 40; i++) ticket2.sale(); },"B").start();
        new Thread(()-> { for (int i = 0; i < 40; i++) ticket2.sale(); },"C").start();
    }
}
//Lock三部
//1.new ReentrantLock();
//2.lock.lock();//加锁
//3. finally==>lock.unlock();//解锁
    class Ticket2 {
        //属性、方法
        private int number = 30;

       Lock lock = new ReentrantLock();

        public  void sale() {
            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关键字

Lock : 是一个Java类
Synchronized :无法判断获取锁的状态

Lock : 可以判断是否获取了锁
Synchronized ：会自动释放锁

Lock ：必须要手动释放锁！（若果不释放锁，会成为死锁）
Synchronized ：线程1（获得锁，阻塞）；线程2（等待）

Lock ：不一定会等待下去
synchronized ：可重入锁，不可以中断，非公平

Lock ：可重入锁，可以判断锁，非公平（可以设置）

synchronized ：适合锁少量的代码同步问题

Lock：适合锁大量的同步代码

3、生产者和消费者问题

生产者和消费者问题 Synchronized版

package com.pc;
/**
 * 线程之间的通信问题： 生产者和消费者问题
 * 线程交替 A B 操作同一个变量  num=0
 * A  num+1
 * B   num-1
 */

public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

//判断等待  业务  通知
class Data{//数字  资源类
    private  int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
     if (number!=0){
        //等待
         this.wait();
       }
     number++;
     System.out.println(Thread.currentThread().getName()+"=>"+number);
     //通知其他线程  我+1完毕了
        this.notifyAll();
    }


    //-1
    public synchronized void decrement() throws InterruptedException {
        if (number==0){
         //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程  我-1完毕了
        this.notifyAll();
    }
}

问题存在 A B C D 4个线程！虚假唤醒

线程也可以唤醒，而不会被通知，中断或超时，即所谓的虚假唤醒 。虽然这在实践中很少会发生，但应用程序必须通过测试应该使线程被唤醒的条件来防范，并且如果条件不满足则继续等待。换句话说，等待应该总是出现在循环中(注意：防止虚假唤醒问题），就像这样：

  synchronized (obj) {
           while (<condition does not hold>)
               obj.wait(timeout);
           ... // Perform action appropriate to condition
       }

解决： if 改为while

package com.pc;
public class B {
    public static void main(String[] args) {
        Data2 data2 = new Data2();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

class Data2{//数字  资源类
    private  int number = 0;
    //+1
    public synchronized void increment() throws InterruptedException {
      while (number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程  我+1完毕了
        this.notifyAll();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
        while (number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程  我-1完毕了
        this.notifyAll();
    }
}

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

通过Lock找到Condition

 class BoundedBuffer {
    final Lock lock = new ReentrantLock();
    final Condition notFull  = lock.newCondition(); 
    final Condition notEmpty = lock.newCondition(); 
 
    final Object[] items = new Object[100];
    int putptr, takeptr, count;
 
    public void put(Object x) throws InterruptedException {
      lock.lock(); try {
        while (count == items.length)
          notFull.await();
        items[putptr] = x;
        if (++putptr == items.length) putptr = 0;
        ++count;
        notEmpty.signal();
      } finally { lock.unlock(); }
    }
 
    public Object take() throws InterruptedException {
      lock.lock(); try {
        while (count == 0)
          notEmpty.await();
        Object x = items[takeptr];
        if (++takeptr == items.length) takeptr = 0;
        --count;
        notFull.signal();
        return x;
      } finally { lock.unlock(); }
    }
  }

代码实现

package com.pc;

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

public class C {
    public static void main(String[] args) {
        Data3 data2 = new Data3();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
class Data3{//数字  资源类
    private  int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //+1
    public  void increment() throws InterruptedException {
        lock.lock();
        try {
            //业务代码
            while (number!=0){
                condition.await();//等待
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程  我+1完毕了
            condition.signal();
        }catch (Exception e){
                e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    //-1
    public  void decrement() throws InterruptedException {
        lock.lock();
        try {
            //业务代码
            while (number==0){
                condition.await(); //等待
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程  我+1完毕了
            condition.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

Condition 精准的通知唤醒线程

代码实现 A B C D顺序执行

package com.pc;

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 D {
    public static void main(String[] args) {
        Data4 data = new Data4();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();
    }
}

class Data4{//资源类 Lock

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1;//1A 2B 3C

    public void printA(){
        lock.lock();
        try {
           //业务  判断-》执行-》通知
            while (number!=1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"====>AAAA");
            //唤醒 唤醒指定的人 B
            number =2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public void printB(){
        lock.lock();
        try {
            //业务  判断-》执行-》通知
            while (number!=2){
               condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBBB");
            //唤醒 唤醒指定的人 C
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public void printC(){
        lock.lock();
        try {
            //业务  判断-》执行-》通知
            while (number!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCCCCCCC");
            //唤醒 唤醒指定的人 C
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

4、八锁现象

如何判断锁是谁! 什么是锁锁到底锁的谁！

8锁：就是关于锁的8个问题

1.标准情况下，两个线程先打印发短信还是打电话？ 1/发短信 2/打电话

2.sedSms延迟4秒，两个线程先打印发短信还是打电话？ 1/发短信 2/打电话

package com.lock8;
/*
* 8锁：就是关于锁的8个问题
* 1.标准情况下，两个线程先打印  发短信还是 打电话？ 1/发短信 2/打电话
* 2.sedSms延迟4秒，两个线程先打印  发短信还是 打电话？ 1/发短信 2/打电话
* */
import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        //锁的存在
        new Thread(()-> {
           phone.sendSms();
        },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}

class  Phone{
    //synchronized 锁的对象是方法的调用者
    // 两个方法用的同一个锁，谁先拿到谁先用
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

3.增加了一个普通方法后，先执行发短信还是hello？普通方法 1/hello 2/发短信

4.两个对象，两个同步方法，先执行发短信还是打电话? 1/打电话 2/发短信

package com.lock8;

import java.util.concurrent.TimeUnit;
/*
 * 3.增加了一个普通方法后，先执行发短信还是hello？ 普通方法 1/hello 2/发短信
 * 4.两个对象，两个同步方法，先执行发短信还是打电话? 1/打电话 2/发短信
 * */
public class Test2 {
    public static void main(String[] args) {
        //两个对象,两个调用者，两把锁！
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        //锁的存在
        new Thread(()-> {
            phone1.sendSms();
        },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class  Phone2{
    //synchronized 锁的对象是方法的调用者
    public synchronized void sendSms(){
        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");
    }
}

5.增加两个静态的同步对象，只有一个对象，先打印发短信还是打电话? 1/发短信 2/打电话

6.两个对象！增加两个静态的同步对象，先打印发短信还是打电话? 1/发短信 2/打电话

package com.lock8;

import java.util.concurrent.TimeUnit;
/*
* 5.增加两个静态的同步对象，只有一个对象，先打印发短信还是打电话?  1/发短信 2/打电话
* 6.两个对象！增加两个静态的同步对象，先打印发短信还是打电话?  1/发短信 2/打电话
* */
public class Test3 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        //锁的存在
        new Thread(()-> {
            phone1.sendSms();
        },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
//Phone3唯一的一个Class 对象
class  Phone3{
    //synchronized 锁的对象是方法的调用者
    //static 静态方法
    //类一加载就有了！ 锁的是Class
    public  static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

7.1个静态的同步方法，1个普通的同步方法，一个对象，先打印发短信还是打电话？1/打电话 2/发短信

8.1个静态的同步方法，1个普通的同步方法，两个个对象，先打印发短信还是打电话？1/打电话 2/发短信

package com.lock8;

import java.util.concurrent.TimeUnit;
/*
* 7.1个静态的同步方法，1个普通的同步方法，一个对象，先打印 发短信还是打电话？1/打电话 2/发短信
* 8.1个静态的同步方法，1个普通的同步方法，两个个对象，先打印 发短信还是打电话？1/打电话 2/发短信
* */
public class Test4 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static，锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();


        //锁的存在
        new Thread(()-> {
            phone1.sendSms();
        },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
//Phone3唯一的一个Class 对象
class  Phone4{
    //静态的同步方法 锁的class模板
    public  static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    //普通的同步方法 锁的调用者
    public  synchronized void call(){
        System.out.println("打电话");
    }
}

小结： new this 具体的一个手机 static Class 唯一的一个模板

5、集合类不安全

List不安全

并发下ArrayList 不安全 java.util.ConcurrentModificationException 并发修改异常
解决方案：
List list = new Vector<>();
List list = Collections.synchronizedList(new ArrayList<>());
List list = new CopyOnWriteArrayList<>();
CopyOnWrite

写入时复制 COW 计算机程序设计领域的一种优化策略
多线程调用时，list，读取的时候，固定的，写入(覆盖)
在写入时候避免覆盖，造成数据问题！
例题：

package com.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

//java.util.ConcurrentModificationException 并发修改异常
public class ListTest {
    public static void main(String[] args) {
        //并发下ArrayList 不安全
        /*
        解决方案：
        1、List<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 = 1; i <= 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

Set不安全

解决方案：
List list = Collections.synchronizedList(new ArraySet<>());
List list = new CopyOnWriteArraySet<>();
例题

package com.unsafe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentSkipListSet;
import java.util.concurrent.CopyOnWriteArraySet;

//java.util.ConcurrentModificationException 并发修改异常
/*
* 解决方案：
* 1.Set<String> set = Collections.synchronizedSet(new HashSet<>());
* 2.Set<String> set = new ConcurrentSkipListSet<>();
* */
public class SetTest {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

hashSet底层是什么？

pubilc HashSet(){
    map = new HashMap<>();
}

//add  set的本质就是 map key是无法重复的
private static final Object PRESENT = new Object();//不变值！

Map不安全

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

package com.unsafe;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
//ConcurrentModificationException 并发修改异常
public class MapTest {
    public static void main(String[] args) {
    //new HashMap<>(16,0.75);  默认值
    //Map<String,String> map =new HashMap<>(16,0.75);
    // Map<String,String> map =new ConcurrentHashMap<>();
        Map<String,String> map =new ConcurrentHashMap<>();
        for (int i = 1; i <= 30 ; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

ConcurrentHashMap

concurrentHashMap是一个支持高并发更新与查询的哈希表(基于HashMap)。
在保证安全的前提下，进行检索不需要锁定。与hashtable不同，该类不依赖于synchronization去保证线程操作的安全。
hashMap的数据结构：

在这里插入图片描述

如何高效的执行并发操作：
根据上面hashMap的数据结构可以直观的看到，如果以整个容器为一个资源进行锁定，那么就变为了串行操作。而根据hash表的特性，具有冲突的操作只会出现在同一槽位，而与其它槽位的操作互不影响。
基于此种判断，那么就可以将资源锁粒度缩小到槽位上，这样热点一分散，冲突的概率就大大降低，并发性能就能得到很好的增强

在这里插入图片描述

如何进行锁的选择：
ConcurrentHashMap使用JUC包中通过直接操作内存中的对象，将比较与替换合并为一个原子操作的乐观锁形式（CAS）来进行简单的值替换操作，对于一些含有复杂逻辑的流程对Node节点对象使用synchronize进行同步。
Node节点类型与作用
回顾HashMap，其中Node节点类型包含两种，第一种链表，第二种红黑树。
而在ConcurrentHashMap中节点类型在上述两种的基础上扩展了，两种分别是ForwardingNode
和 ReservationNode。
ForwardingNode：用于解决当进行扩容的时候，进行查询的问题。
ReservationNode：用于解决当进行计算时，计算的对象为空的问题。

槽位hash值含义：
链表：大于0
ForwardingNode：-1
红黑树：-2
ReservationNode：-3

6.扩容的方式
基于hashMap的扩容方式，通过成员的最新bit位是1or0来决定是否将成员迁入新的槽位中。
显而易见，这种扩容方式对于槽位之间也是互不影响的，那么就可以进行并发的执行扩容以达到高效的目的。

在这里插入图片描述

节点为空则直接替换为Forwarding，后续操作就在新容器中开展。
如果节点不为空，则对节点处理完毕后变更为Forwarding。

在这里插入图片描述

    /**
     * Table initialization and resizing control.  When negative, the
     * table is being initialized or resized: -1 for initialization,
     * else -(1 + the number of active resizing threads).  Otherwise,
     * when table is null, holds the initial table size to use upon
     * creation, or 0 for default. After initialization, holds the
     * next element count value upon which to resize the table.
     */
    private transient volatile int sizeCtl;

○ 负数
■ -1：容器进行初始化
■ 其余负数：高16存储resizeStamp()返回的扩容标识符，低16位（1+进行扩容的线程数）
○ 正数
■ 0：未初始化，需要进行初始化
■ 其余正数：当前容器的大小

6、Callable

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

可以有返回值
可以抛出异常
方法不同 run() / call()

new Thread().start();//怎么实现Callable
//new Thread(new Runnable()).start();
//new Thread(new FutureTask<>()).start();
//new Thread(new FutureTask<>(Callable)).start();

测试：

package com.Callable;

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

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //new Thread(new Runnable()).start();
        //new Thread(new FutureTask<>()).start();
        //new Thread(new FutureTask<>(Callable)).start();
        new Thread().start();//怎么实现Callable

        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();
    }
}
class MyThread implements Callable<Integer> {
    @Override
    public Integer call(){
        System.out.println("call()");
        //耗时的操作
        return 1024;
    }
}

7、常用辅助类

CountDownLatch

允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。
A CountDownLatch用给定的计数初始化。await方法阻塞，直到由于countDown()方法的调用而导致当前计数达到零，之后所有等待线程被释放，并且任何后续的await调用立即返回。这是一个一次性的现象 - 计数无法重置。如果您需要重置计数的版本，请考虑使用CyclicBarrier 。
A CountDownLatch是一种通用的同步工具，可用于多种用途。一个CountDownLatch为一个计数的CountDownLatch用作一个简单的开/关锁存器，或者门：所有线程调用await在门口等待，直到被调用countDown()的线程打开。一个CountDownLatch初始化N可以用来做一个线程等待，直到N个线程完成某项操作，或某些动作已经完成N次。

例题：减法计数器

原理：
countDownLatch.countDown(); //数量减1
countDownLatch.await(); //等待计数器归零，然后向下执行
每次有线程调用countDown() 数量减1，假设计数器变为0，countDown.await()就会被唤醒，继续执行！

package com.add;
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()+"Go out");
                countDownLatch.countDown();//数量减1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//等待计数器归零，然后向下执行
        System.out.println("close door");
    }
}

CyclicBarrier

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

例题：召唤神龙（加法计数器）

package com.add;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    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 ;
            //lambda能操作到 i 吗
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");

                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore(信号量)

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

例题：抢车位

原理：
semaphore.acquire();获得，假设已经满了，等待，等待被释放为止
semaphore.release();释放，会将当前的信号量释放+1，然后唤醒等待的线程
作用：多个共享资源互斥的使用！并发限流，控制最大的线程数！

package com.add;

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 <= 6; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();//acquire() 得到
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();release() 释放
                }
            },String.valueOf(i)).start();
        }
    }
}

8、读写锁

ReadWriteLock（读写锁）

A ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行，只要没有作者。write lock是独家的。(读的时候可以被多个线程同时读，写的时候只能有一个线程去写)
读写锁允许访问共享数据时的并发性高于互斥锁所允许的并发性。
读写锁是否会提高使用互斥锁的性能取决于数据被读取的频率与被修改的频率相比，读取和写入操作的持续时间以及数据的争用 - 即是，将尝试同时读取或写入数据的线程数。

代码操作

package com.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/*
*  ReadWriteLock
*  读-读  可以共存
* 读-写  不能共存
* 写-写   不能共存
* 独占锁（写锁）一次只能一个线程占有
* 共享锁（读锁）多个线程可以同时占有
* */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();

        //写入
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
               myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }

        //读取
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }
    }
}

//加锁
class MyCacheLock{
    private volatile Map<String,Object> map = new HashMap<>();
    //读写锁： 更加细粒度的操作
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //存  写入的时候，只希望同时只有一个线程写入
    public  void put(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");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            readWriteLock.writeLock().unlock();
        }

    }

    //取  读 所有人都能读
    public void get(String key){
        readWriteLock.readLock().lock();

        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

/*
* 自定义缓存
* */
class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();

    //存  写
    public  void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入"+key);
       map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入OK");
    }

    //取  读
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取OK");
    }
}

9、阻塞对列

写入：如果对列满了，就必须阻塞等待；取：如果对列是空的，必须阻塞等待生产
BlockingQueue BlockingQueue不是新东西
什么情况下我们会使用阻塞对列，多线程并发处理，线程池！
阻塞对列：
Interface BlockingQueue
- 参数类型
E - 此集合中保存的元素的类型
- All Superinterfaces:
Collection ， Iterable ， Queue
- All Known Subinterfaces:
BlockingDeque， TransferQueue
- 所有已知实现类：
ArrayBlockingQueue ， DelayQueue ， [LinkedBlockingDeque ， LinkedBlockingQueue ， LinkedTransferQueue ， PriorityBlockingQueue ， SynchronousQueue
对列
Interface Queue
- 参数类型
  E - 保存在此集合中的元素的类型
- All Superinterfaces:
  
  Collection ， Iterable
- All Known Subinterfaces:
  
  BlockingDeque， BlockingQueue， Deque， TransferQueue
- 所有已知实现类：
  
  AbstractQueue， ArrayBlockingQueue ， ArrayDeque ， ConcurrentLinkedDeque ， ConcurrentLinkedQueue， DelayQueue， LinkedBlockingDeque ， inkedBlockingQueue ， LinkedList， LinkedTransferQueue ， PriorityBlockingQueuel ， PriorityQueue ， SynchronousQueue

学会使用对列

1. 四组API  :  抛出异常 ，不会抛出异常  ，阻塞 等待  ，超时等待

方式	抛出异常	有返回值，不抛异常	阻塞等待	超时等待
添加	add	offer()	put()	offer(,)
移除	remove	poll()	take()	put(,)
检测队首元素	element	peek()	-	-

抛出异常

      /*
    * 抛出异常
    * */
    public static void test1(){
        //队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        //IllegalStateException: Queue full 抛出异常！
        //System.out.println(blockingQueue.add("d"));
        System.out.println("============================");
        
        System.out.println(blockingQueue.element());查看队首元素是谁
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        //NoSuchElementException 抛出异常！
        //System.out.println(blockingQueue.remove());
    }    System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        //NoSuchElementException 抛出异常！
        //System.out.println(blockingQueue.remove());
    }

有返回值，不抛异常

/*
    * 有返回值，没有异常
    * */
    public  static void test2(){
        //队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        //System.out.println(blockingQueue.add("d"));  //false 不抛出异常
        
        System.out.println(blockingQueue.peek());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());//null 不抛出异常
    }

阻塞等待

   /*
    * 等待，阻塞 (一直阻塞)
    * */
    public static void test3() throws InterruptedException {
        //队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        //一直堵塞
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
        blockingQueue.put("d"); //队列没有位置，一直阻塞
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());//没有这个元素，一直阻塞
    }

等待超时

   public static void test4() throws InterruptedException {
        //队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        //一直堵塞
       blockingQueue.offer("a");
       blockingQueue.offer("b");
       blockingQueue.offer("c");
       blockingQueue.offer("d",2,TimeUnit.SECONDS);//等待超过2秒就退出
        System.out.println("============");
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS));

    }

SynchronousQueue同步对列

没有容量
进去一个元素，必须等到取出来之后，才能往里放一个元素！
put() take()
同步队列
- 和其他的blockingQueue 不一样，SynchronousQueue 不存储元素
- put了一个元素，必须从里面take取出来，否则不能在put进去值！

例题

package com.bq;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/*
* 同步队列
* 和其他的blockingQueue 不一样，SynchronousQueue 不存储元素
* put了一个元素，必须从里面take取出来，否则不能在put进去值！
* */
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();//同步队列


            new Thread(()->{
                try {
                    System.out.println(Thread.currentThread().getName()+"put 1");
                    blockingQueue.put("1");
                    System.out.println(Thread.currentThread().getName()+"put 2");
                    blockingQueue.put("2");
                    System.out.println(Thread.currentThread().getName()+"put 3");
                    blockingQueue.put("3");
                } catch (Exception 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").start();
    }
}

10、线程池（重点）

池化技术

程序的运行，本质：占用系统的资源！优化资源的使用=》池化技术
池化技术：事先准备好一些资源，用时拿，用完还
线程池，连接池，内存池，对象池//… 创建，销毁，十分浪费资源
线程池的好处：
1. 降低资源的消耗 2. 提高响应速度 3. 方便管理
  
  线程复用，可以控制最大并发数，管理线程
线程池：三大方法 7大参数 4种拒绝策略

线程池：三大方法

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明：Executors 返回的线程池对象的弊端如下：

FixedThreadPool 和 SingleThreadPool: 允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
CachedThreadPool 和 ScheduledThreadPool: 允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

代码实现

package com.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//Executors 工具类  3大方法
public class Demo1 {
    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 < 10; i++) {
              //使用线程池之后，使用线程来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"  OK");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程
            threadPool.shutdown();
        }
    }
}

7大参数

源码分析：

//newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

//newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

//newCachedThreadPool
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<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;
    }

例题：手动创建线程

package com.pool;

import java.util.concurrent.*;

public class Demo2 {
//自定义线程池！ 工作 ThreadPoolExecutor
        /*
        * new ThreadPoolExecutor.AbortPolicy());//满了，还进来，不处理，抛出异常
        * new ThreadPoolExecutor.CallerRunsPolicy());//哪来的去哪里
        * new ThreadPoolExecutor.DiscardPolicy());//对列满了，丢掉任务，不会抛出异常，
        * new ThreadPoolExecutor.DiscardOldestPolicy());new ThreadPoolExecutor.DiscardOldestPolicy());
        * */
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());//对列满了，尝试和最早的竞争，不会抛出异常!


        try {
            //最大承载 Deque + max
            //超过 RejectedExecutionException
        for (int i = 1; i <= 9; i++) {
            //使用线程池之后，使用线程来创建线程
            threadPool.execute(()->{
                System.out.println(Thread.currentThread().getName()+"  OK");
            });
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        //线程池用完，程序结束，关闭线程
        threadPool.shutdown();
    }
}
}

4种拒绝策略

        /*
        * new ThreadPoolExecutor.AbortPolicy());//满了，还进来，不处理，抛出异常
        * new ThreadPoolExecutor.CallerRunsPolicy());//哪来的去哪里
        * new ThreadPoolExecutor.DiscardPolicy());//对列满了，丢掉任务，不会抛出异常，
        * new ThreadPoolExecutor.DiscardOldestPolicy());new ThreadPoolExecutor.DiscardOldestPolicy());
        * */

拓展

最大线程到底该如何定义
CPU密集型：几核，就是几，可以保持CPU效率最高
```
System.out.println(Runtime.getRuntime().availableProcessors());
   //获得CPU的核数
```
IO 密集型：判断程序中十分耗IO的线程
池的最大的大小如何设置！
了解：IO密集型 CPU密集型（调优）

package com.pool;
import java.util.concurrent.*;
public class Demo2 {
/*
最大线程到底该如何定义
   1.CPU密集型：几核，就是几，可以保持CPU效率最高
   2.IO 密集型：判断程序中十分耗IO的线程
*/
    public static void main(String[] args) {       System.out.println(Runtime.getRuntime().availableProcessors());
  //获取CPU核数
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
            Runtime.getRuntime().availableProcessors();
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());//对列满了，尝试和最早的竞争，不会抛出异常!


        try {
            //最大承载 Deque + max
            //超过 RejectedExecutionException
        for (int i = 1; i <= 9; i++) {
            //使用线程池之后，使用线程来创建线程
            threadPool.execute(()->{
                System.out.println(Thread.currentThread().getName()+"  OK");
            });
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        //线程池用完，程序结束，关闭线程
        threadPool.shutdown();
    }
}
}

11、四大函数式接口（重点）

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

@FunctionalInterface
public interface Runnable {
public abstract void run();
}
//超级多FunctionalInterface
//简化编程模型,在新版本的框架底层大量应用!
//foreach(消费者的函数式接口)

四大函数式接口： Consumer , Function, Predicate , Supplier

Function 函数式接口

Function 函数式接口:

1.有一个输入参数，一个输出
2.只要是函数式接口可以用 Lambda表达式简化 Function function = (str)->{return"asd";};

源码：

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

代码实现

package com.function;

import java.util.function.Function;

/*
* Function 函数式接口
* 1.有一个输入参数，一个输出
* 2.只要是 函数式接口 可以用 Lambda表达式简化   Function function = (str)->{return"asd";};
* */
public class Demo1 {
    public static void main(String[] args) {
    /*    工具类 输出输入的值
        Function function = new Function<String,String>() {
            @Override
            public String apply(String str) {
                return str;
            }
        };
       */
        Function function = (str)->{return"asd";};
        System.out.println(function.apply("asd"));
    }
}

Predicate 断定型接口

断定型接口：

1.有一个输入参数，返回值只能是布尔值！
2.Lambda表达式简化 Predicate predicate = (str)->{return str.isEmpty();};

源码：

@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);

代码实现

package com.function;

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

Consumer 消费型接口

源码：
```
```java
```
@FunctionalInterface
public interface Consumer {
void accept(T t);
```
Consumer 消费型接口
1. 只有输入，没有返回值
  2.Lambda表达式简化 Consumer consumer = (str)->{System.out.println(str);};
代码实现

package com.function;
import java.util.function.Consumer;
/*
Consumer 消费型接口
1. 只有输入，没有返回值
2.Lambda表达式简化 Consumer<String> consumer = (str)->{System.out.println(str);};
 */
public class Demo3 {
    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("sasasad");
    }
}

Supplier供给型接口

源码

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

Supplier 供给型接口
1.没有参数只有返回值
2.Lambda表达式简化 Supplier supplier = ()->{return 1024;};
代码实现

package com.function;

import java.util.function.Supplier;
/*
Supplier 供给型接口 
1.没有参数 只有返回值
2.2.Lambda表达式简化  Supplier<Integer> supplier = ()->{return 1024;};
 */
public class Demo4 {
    public static void main(String[] args) {
     /*   Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                System.out.println("get()");
                return 1024;
            }
        };
      */
        Supplier<Integer> supplier = ()->{return 1024;};
        System.out.println(supplier.get());
    }
}

12、Stream流式计算

什么是Stream流式计算
大数据：存储 + 计算
集合、MySQL本质就是存储东西
计算机都应该交给流操作!
Interface Stream
参数类型
T - 流元素的类型
- All Superinterfaces:
  AutoCloseable ， BaseStream <T， Stream>

package com;

import java.util.Arrays;
import java.util.List;
import java.util.Locale;

/*
* 题目：只能用一行代码实现
* 现有5个用户！ 筛选
* 1.ID 必须是偶数
* 2. 年龄必须大于23岁
* 3. 用户名转写为大写
* 4.用户名字母到倒着排序
* 5.只输出一个用户！
* */
public class test {
    public static void main(String[] args) {
        User u1 = new User(1, "a", 21);
        User u2 = new User(2, "b", 22);
        User u3 = new User(3, "c", 23);
        User u4 = new User(4, "d", 24);
        User u5 = new User(5, "e", 25);
       //集合就是存储
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);

        //计算交给Stream流
        //Lambda表达式  链式接口  函数式接口 Stream流式计算
        list.stream()
                .filter(u->{return u.getId()%2==0;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase(Locale.ROOT);})
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);
    }
}

13、ForkJoin

什么是ForkJoin?

并行执行任务！提高效率，大数据！

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

在这里插入图片描述

特点：工作窃取(维护的都是双端队列)
- ForkJoinPool的各个工作线程都会维护一个各自的任务队列，减少线程之间对于任务的竞争；
- 每个线程都会先保证将自己队列中的任务执行完，当自己的任务执行完之后，会去看其他线程的任务队列中是否有未处理完的任务，如果有则会帮助其他线程执行；
- 为了减少在帮助其他线程执行任务时发生竞争，会使用双端队列来存放任务，被窃取的任务只会从队列的头部获取任务，而正常处理的线程每次都是从队列的尾部获取任务。

例题

测试类：

package forkjoin;

import java.util.concurrent.RecursiveTask;

/*
* 求和计算的任务!
* //如何使用forkjoin
* //1.forkjoinPool 通过他执行
* //2.计算任务 forkjoinPool.execute(ForkJoinTask Task)
* //3. 计算类要继承ForKJoinTask
* */
public class ForkJoinDemo extends RecursiveTask<Long> {
    private Long start; //1
    private Long end;   //1990900000

    //临界值
    private Long temp = 10000L;

    public ForkJoinDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }
    //计算方法
    @Override
    protected Long compute() {
        if ((end-start)<temp) {
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
                sum += 1;
            }
            return sum;
        }else {//forkjoin
            long middle = (start + end) / 2;//中间值
            ForkJoinDemo test1 = new ForkJoinDemo(start, middle);
            test1.fork();//拆分任务，把任务压入线程对列
            ForkJoinDemo test2 = new ForkJoinDemo(middle+1,end);
             test2.fork();//拆分任务，把任务压入线程对列

            return test1.join() + test2.join();
        }
    }
}

测试：

package forkjoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

public class Teat {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        test1();  //7520
        // test2(); //5453
        //  test3();  //165
    }
    //普通
    public static void test1(){
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= 10_0000_0000; i++) {
            sum += 1;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"时间："+(end-start));
    }
   //ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);//提交任务

        Long sum = submit.get();

        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"时间："+(end-start));
    }
    //Stream并行流
    public static void test3(){
        long start = System.currentTimeMillis();

        long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);

        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"时间："+(end-start));
    }
}

14、异步回调

异步回调 CompletableFuture：异步执行成功回调失败回调
Class CompletableFuture
- java.lang.Object
- java.util.concurrent.CompletableFuture
- All Implemented Interfaces:
  CompletionStage， Future
在java并发编程中，要获取结果需要通过回调函数来获取，常用的有Future接口，此接口有一个CompletableFuture实现类用于异步回调。

没有返回值的runAsync 异步回调

public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //没有返回值的runAsync 异步回调
        CompletableFuture<Void> completableFuture  = CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"runAsync=>Void");

        });
        System.out.println("11111");
        completableFuture.get();//获取阻塞执行结果
    }
}

有返回值的supplyAsync 异步回调

public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
      //有返回值的supplyAsync 异步回调
      CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
          System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
          int i = 10/0;
          return 1024;
      });
      completableFuture.whenComplete((t,u)->{
          System.out.println("t=>"+t);//正常的返回结果
          System.out.println("u=>"+t);//错误的信息   java.lang.ArithmeticException: / by zero
      }).exceptionally((e)->{
          System.out.println(e.getMessage());
          return 233;//可以获得错误的返回结果
      }).get();
    }
}

15、JMM

Volatile的理解

Volatile 是java虚拟机提供的轻量级的同步机制
1、保证可见性
2、不保证原子性
3、禁止指令重排

什么是JMM

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

关于JMM的一些同步约定:

线程解锁前，必须把变量立即刷回主存
线程加锁前，必须读取主存中的最新值到工作内存中！
加锁和解锁是一把锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lcy0LKUx-1669100397014)(D:\JAVA学习\JAVA学习文本\阶段一\多线程进阶之JUC并发编程\JMM.png)]

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

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

JMM对这八种指令的使用，制定了如下规则：

不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
不允许一个线程将没有assign的数据从工作内存同步回主内存
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
对一个变量进行unlock操作之前，必须把此变量同步回主内存

16、Volatile

保证可见性

例题

package com.Volatile;
import java.util.concurrent.TimeUnit;
public class Demo {
    // 不加 volatile 程序就会死循环
    // 加  volatile 可以保证可见性
    private volatile static int num = 0;

    public static void main(String[] args) {//main
        new Thread(()->{//线程 1 对主内存的变化不知道
            while (num==0){
            }
        }).start();

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

不保证原子性

线程A在执行任务的时候，不能被打扰，也不能被分割，要么同时成功，要么同时失败

例题

package com.Volatile;
//不保证原子性
public class Demo2 {
    //volatile   不保证原子性
    private volatile static int num = 0;
    public  static void add(){
      num++;//不是一个原子性操作
    }
    public static void main(String[] args) {
        //理论上num的结果为2万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                } 
            }).start();
        }
        while (Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

如果不加Lock 和 synchronizwd, 怎样保证原子性

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

package com.Volatile;

import java.util.concurrent.atomic.AtomicInteger;

//不保证原子性
public class Demo2 {
    //volatile   不保证原子性
    //原子类的 Integer
    private volatile static AtomicInteger num = new AtomicInteger();
    public  static void add(){
      //num++;  不是一个原子性操作
        num.getAndIncrement();//AtomicInteger + 1方法 CAS
    }
    public static void main(String[] args) {
        //理论上num的结果为2万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                } 
            }).start();
        }
        while (Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

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

4.指令重排

你写的程序，计算机并不是按照你写的那样去执行的
过程：源代码—》编译器优化的重排—》指令并行也可能重排—》内存系统也会重排—》执行

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

int x = 1;//1
int x = 2;//2
x = x + 5;//3
y = 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
x=a	y=b
b=1	a=2

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

volaile可以避免指令重排

内存屏障 CPU指令作用：

1、保证特定的操作的执行顺序！

2、可以保证某些变量的内存可见性（利用这些特征volatile实现可见性）

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

17、单列模式

饿汉式

package com.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;
    }
}

懒汉式

package com.single;
//懒汉式单例

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class LazyMan {
    private static boolean he = false;
    private LazyMan() {
        synchronized (LazyMan.class){
            if (he == false){
                he = true;
            }else {
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }
    }

    private 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) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        //LazyMan instance = LazyMan.getInstance();

        Field he = LazyMan.class.getDeclaredField("he");
        he.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        he.set(instance,false);

        LazyMan instance1 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);

    }
}
/*
 * 1.分配内存空间
 * 2.执行构造方法，初始化对象
 * 3.把这个对象指向这个空间
 */

静态内部类

package com.single;
//静态内部类
public class Holder {
    private Holder(){

    }
      public static Holder getInstance(){
        return InnerClass.HOLDER;
      }

    public static class InnerClass {
        private static final Holder HOLDER = new Holder();
    }
}

单例不安全，因为有反射

枚举

package com.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
//enum 是什么？ 本身也是一个Class类
public enum EnumSingle {

    INSTANCE;

    public  EnumSingle getInstance(){
        return INSTANCE;
    }

}
class Test{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);

        declaredConstructor.setAccessible(true);
        EnumSingle instance = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);

    }
}

17、CAS

什么是CAS

例题

package cas;
import java.util.concurrent.atomic.AtomicInteger;
public class casdemo1 {

    // CAS compareAndSet :比较并交换！
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        //期望，更新
        //public final boolean compareAndSet (int expect, int update)
        //如果我期望的值达到了，那么就更新，否则，就不要更新， CAS 是CPU的并发原语！
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        atomicInteger.getAndIncrement();

        System.out.println(atomicInteger.compareAndSet(2020,2021));
        System.out.println(atomicInteger.get());
    }
}

Unsafe类

Java无法操作内存
Java可以调用c++ native，C++可以调用内存
Java的后门，可以通过这个类操作内存

源码

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

CAS：比较当前工作内存中的值，如果这个值是期望的，则执行操作！如果不是就一直循环下去

缺点

1、循环耗时 2、一次性只能保证一个共享变量的原子性 3、ABA问题

CAS：ABA问题(狸猫换太子)

在这里插入图片描述

package cas;

import java.util.concurrent.atomic.AtomicInteger;

public class ABA {

    // CAS compareAndSet :比较并交换！
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        //期望，更新
        //public final boolean compareAndSet (int expect, int update)
        //如果我期望的值达到了，那么就更新，否则，就不要更新， CAS 是CPU的并发原语！
      //=======================捣乱线程==================================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2021,2021));
        System.out.println(atomicInteger.get());
    //=================期望线程===========================
        System.out.println(atomicInteger.compareAndSet(2020,6666));
        System.out.println(atomicInteger.get());
    }
}

19、原子引用

注意：
1、Integer使用了对象缓存机制，默认范围是-128~127，推荐使用静态工厂方法valueOf获取对象，而不是new，因为valueOf使用缓存，而new一定会创建新的对象分配新的空间；

2、Integer对象是在IntegerCache.cache产生，会复用已有对象，这个区间内的Integer值可以直接使用==进行判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用用已有对象，建议使用equals方法进行判断

3、解决ABA问题，引入原子引用

例题：带原子的原子操作！

package cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

public class ABA {

    // CAS compareAndSet :比较并交换！
    public static void main(String[] args) {
     //   AtomicInteger atomicInteger = new AtomicInteger(2020);
    //atomicStampedReference 注意：如果泛型是一个包装类，注意对象的引用问题
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//获得版本号
            System.out.println("a1=>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a2=>"+atomicStampedReference.getStamp());
          System.out.println(atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a3=>"+atomicStampedReference.getStamp());

        },"a").start();


        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//获得版本号
            System.out.println("b1=>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(1, 6, stamp, stamp + 1));
           System.out.println("b2=>"+atomicStampedReference.getStamp());
       },"b").start();

    }
}

20、各种锁的理解

公平锁非公平锁

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

public ReentrantLock(){
    sync = new NonfairSync();
}

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

public ReentrantLock(boolean fair){
    sync = fair ? new FairSync(): new NonfairSync();
}

可重入锁（递归锁）

拿到外面的锁，相当于可以拿到里面的锁，自动获得

synchronized版

package com.LOCK;
//synchronized
public class sync {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sms();
        },"A").start();

        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}

class Phone{
    public synchronized void sms(){
        System.out.println(Thread.currentThread().getName()+"sms");
        call();//这里也有锁
    }

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

Lock版

package com.LOCK;

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

public class Reentrant {
    public static void main(String[] args){
        Phone2 phone = new Phone2();

        new Thread(()->{
            phone.sms();
        },"A").start();

        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}

class Phone2{
    Lock lock = new ReentrantLock();

    public void sms(){
        lock.lock();// 细节问题： lock.lock();  lock.unlock();   //Lock 锁必须配对，否则会死在里面
        try {
            System.out.println(Thread.currentThread().getName()+"sms");
            call();//这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        }
        lock.unlock();
    }

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

自旋锁(spinLock)

public final int getAndAddInt(Object var1, long var2, int var4){
int var5;
do{
var5 = this.getIntVolatile(var1, var2);
  }while(!this.compareAndSwapInt(var1,var2,var5,var5 + var4));
  return var5;
}

自定义锁测试

package com.LOCK;

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.ReentrantLock;

public class SpinlockDemo {

    //int 0
    // Thread null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==>mylock");

        //自旋锁
        while (!atomicReference.compareAndSet(null, thread)) {

        }
    }
        //解锁
        //加锁
        public void myUnLock(){
            Thread thread = Thread.currentThread();
            System.out.println(Thread.currentThread().getName()+"==>myUnlock");
            atomicReference.compareAndSet(thread,null);
            }
    }

测试

package com.LOCK;

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

public class TsetSpinlock {
    public static void main(String[] args) throws InterruptedException {
        SpinlockDemo spinlockDemo = new SpinlockDemo();

        new Thread(()->{
            spinlockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinlockDemo.myUnLock();
            }
        },"t1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            spinlockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinlockDemo.myUnLock();
            }
        },"t2").start();
    }
}

死锁

死锁是指多个进程在运行过程中因争夺资源而造成的一种僵局，若无外力作用，它们都将无法再向前推进。
死锁产生的四个必要条件

互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。

循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

例题

package com.LOCK;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        new Thread(new MyThread(lockA,lockB),"T1").start();
        new Thread(new MyThread(lockB,lockA),"T2").start();
    }
}

class MyThread implements Runnable {

    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "lock:" + lockA + "==>get" + lockB);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "lock:" + lockB + "==>get" + lockA);
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}