JUC并发编程

最新推荐文章于 2024-10-06 20:16:20 发布

sula.xu

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量115

点赞数

分类专栏： JUC并发编程文章标签： java juc

本文链接：https://blog.csdn.net/qq_33286156/article/details/120269219

版权

JUC并发编程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文档使用java官方文档
请添加图片描述
java.util 工具包

之前采用的Thread、Runnable开线程
Runnable 没有返回值且效率相比callable相对较低！
所有我们再企业开发中一般不会采用runnable，而是用callable相对较多

2.线程和进程

进程、线程。如果不能用一句话说出来的技术，不扎实！

一个程序表示一个进程，程序中的任务表示线程。一个程序至少一个线程。

java默认有几个线程？
2个（main，GC），主线程和垃圾回收线程。

之前采用的Thread、Runnable开线程。

java真的可以开启线程么？ 不能
java无法操作硬件，Thread的start方法的底层实现，实际调用的是c++开始线程。

3.并发，并行

并发编程（并发，并行）

并发（多线程操作同一资源）
CPU一核，模拟出来多条线程。天下武功，唯快不破。快速交替。形成的一种假象。
并行（多个人一起行走）
CPU多核，多个线程可以同时执行。线程池请添加图片描述
并发编程的本质：充分利用CPU的资源。

线程有几个状态

public enum State {
        //新生
        NEW,

        //运行
        RUNNABLE,

        //阻塞
        BLOCKED,

        //等待，死死地等
        WAITING,

        //超时等待
        TIMED_WAITING,

        //终止
        TERMINATED;
    }

wait/sleep 区别
1.来自不同的类

wait => Object
sleep => Thread

企业睡眠不会采用sleep睡眠。多会采用以下方式。

import java.util.concurrent.TimeUnit;

TimeUnit.DAYS.sleep(1);
TimeUnit.SECONDS.sleep(1);

2.关于锁的释放

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

3.使用范围是不同的
wait必须使用与同步代码块中。
sleep可以使用再任何地方。

4.是否需要捕获异常
wait 不需要捕获异常
sleep 必须要捕获异常

2.Lock锁（重点）

package org.sula.util;

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

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * 真正的多线程开发，公司中的开发
 * 线程就是一个单独的资源类，没有任何附属操作
 * 属性，方法
 * @Author: liangxu
 * @Date: 2021/9/13 4:51 下午
 * @Version: V1.0
 */
public class Demo1 {

    public static void main(String[] args) {
        final Ticket ticket = new Ticket();

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

//资源类 OOP
//1.创建锁
//2.加锁
//3.解锁
class Ticket{
    //属性、方法
     private int number = 30;

     Lock lock = new ReentrantLock();

     //买票的方式
    public void sale(){
        lock.lock();
        try {
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"卖出了"+number--+"张票");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
}

传统synchronized和lock区别
1.synchronized内置关键字，Lock是一个java类
2.synchronized无法判断获取锁的状态，Lock可以判断是否获取到锁
3.synchronized 自动释放锁，Lock手动释放，如不释放，死锁。
4.synchronized线程1（获得锁、阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去；
lock.tryLock() 可以尝试获取锁。
5.synchronized可重入锁，不可以中断的，非公平；Lock，可重入锁，可以判断锁，默认非公平（但可以自己设置）。
6.synchronized适合少量代码同步问题，Lock适合锁大量的同步代码。

锁是什么？如何判断锁的是谁？
面试：单例模式、排序算法、生产者和消费者、死锁

3.线程通信（生产者和消费者）

3.1synchronized版本的

package org.sula.util;

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/13 5:25 下午
 * @Version: V1.0
 */
public class Demo2 {
    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 num = 0;
    public synchronized void increment() throws InterruptedException {
        //如果存在2个以上线程,采用if判断会存在虚假唤醒问题，所有的wait都应该存在于while循环中
//        if (num != 0){
//            //等待
//            this.wait();
//        }
        while (num != 0){
            //等待
            this.wait();
        }
        num++;
        //通知其他线程，+1完毕
        System.out.println(Thread.currentThread().getName()+"=="+num);
        this.notifyAll();
    }

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

注意：如果存在2个以上线程,采用if判断会存在虚假唤醒问题，所有的wait都应该存在于while循环中

3.2JUC版本

package org.sula.util;

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

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/13 5:25 下午
 * @Version: V1.0
 */
public class Demo3 {
    public static void main(String[] args) {
        LockTest test = new LockTest();
        new Thread(()->{for (int i = 0; i < 10; i++)test.increment();},"A").start();
        new Thread(()->{for (int i = 0; i < 10; i++)test.decrement();},"B").start();
        new Thread(()->{for (int i = 0; i < 10; i++)test.increment();},"C").start();
        new Thread(()->{for (int i = 0; i < 10; i++)test.decrement();},"D").start();
    }
}

//判断等待，业务，通知
class LockTest{
    private int num = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void increment(){
        lock.lock();
        try {
            while (num != 0){
                //等待
                condition.await();
            }
            num++;
            //通知其他线程，+1完毕
            System.out.println(Thread.currentThread().getName()+"=="+num);
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void decrement(){
        lock.lock();
        try {
            while (num == 0){
                //等待
                condition.await();
            }
            num--;
            //通知其他线程，+1完毕
            System.out.println(Thread.currentThread().getName()+"=="+num);
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

请添加图片描述

4.Condition

任何一个新技术，绝对不是仅仅只是覆盖原来的技术，优势和补充！
Condition精准通知和唤醒线程

通过以上的结果，我们不难发现，打印出的线程是随机的。那么如何实现A、B、C、D线程有序执行呢？

package org.sula.util;

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

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/13 5:25 下午
 * @Version: V1.0
 */
public class Demo4 {
    public static void main(String[] args) {
        LockOrderTest test = new LockOrderTest();
        new Thread(()->{for (int i = 0; i < 10; i++) test.PrintA();},"A").start();
        new Thread(()->{for (int i = 0; i < 10; i++) test.PrintB();},"B").start();
        new Thread(()->{for (int i = 0; i < 10; i++) test.PrintC();},"C").start();

    }
}

//判断等待，业务，通知
class LockOrderTest{
    private int num = 1;//1A 2B 3C
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void PrintA(){
        lock.lock();
        try {
            while (num != 1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAAA");
            num = 2;
            condition2.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void PrintB(){
        lock.lock();
        try {
            while (num != 2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBBB");
            num = 3;
            condition3.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void PrintC(){
        lock.lock();
        try {
           while (num != 3){
               condition3.await();
           }
            System.out.println(Thread.currentThread().getName()+"=>CCCCCC");
           num = 1;
           condition1.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

请添加图片描述
如上，采用多个condition监视器，唤醒指定的condition即可。

5.锁是什么，锁的是谁？

关于锁的8个问题：

package org.sula.util;

import java.util.concurrent.TimeUnit;

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 10:08 上午
 * @Version: V1.0
 */

/**
 * 锁的8个问题
 * 1.标准情况下，两个线程先打印 发短信还是打电话？  1.发短信 2.打电话
 * 2.sendSms延迟4秒，两个线程先打印 发短信还是打电话？ 1.发短信 2.打电话
 */

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

        new Thread(()->{phone.sendSms();}).start();

        //睡眠1秒 捕获异常
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

}

class Phone{
    /**
     * 因为有锁的存在，synchronized锁的对象是方法的调用者。
     * 两个方法用的是同一个phone对象锁，所以谁先拿到锁对象，谁先执行！
     */
    public synchronized void sendSms(){
        //睡眠1秒 捕获异常
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

}

package org.sula.util;

import java.util.concurrent.TimeUnit;

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 10:08 上午
 * @Version: V1.0
 */

/**
 * 锁的8个问题
 * 3.增加一个普通方法后，先执行发短信还是hello？普通方法
 * 4.两个对象，两个同步方法，发短信还是打电话？//打电话
 */

public class Demo6 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        Phone1 phone2 = new Phone1();

        new Thread(()->{phone1.sendSms();}).start();

        //睡眠1秒 捕获异常
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

//        new Thread(()->{phone1.hello();}).start();
    }

}

class Phone1{
    /**
     * 因为有锁的存在，synchronized锁的对象是方法的调用者。
     * 两个方法用的是同一个phone对象锁，所以谁先拿到锁对象，谁先执行！
     */
    public synchronized void sendSms(){
        //睡眠1秒 捕获异常
        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 org.sula.util;

import java.util.concurrent.TimeUnit;

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 10:08 上午
 * @Version: V1.0
 */

/**
 * 锁的8个问题
 * 5.增加两个静态的同步方法，只有一个对象，先打印 发短信？还是打电话？   1.发短信 2.打电话
 * 6.两个对象 增加两个静态同步方法，先打印 发短信？打电话？     1.发短信 2.打电话  结果不会改变，因为只有一个类对象。
 */
public class Demo7 {
    public static void main(String[] args) {
    	//两个对象的Class类模板，只有一个，static，锁的是Class
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{phone1.sendSms();}).start();

        //睡眠1秒 捕获异常
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

}

class Phone2{
    /**
     * static 静态方法  类一加载就有了
     * 锁的是Class
     * final Class<Phone2> phone2Class = Phone2.class; 这个Class静态对象，只有唯一一个。
     */
    public static synchronized void sendSms(){
        //睡眠1秒 捕获异常
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }

}

package org.sula.util;

import java.util.concurrent.TimeUnit;

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 10:08 上午
 * @Version: V1.0
 */

/**
 * 锁的8个问题
 * 7.1个静态的同步方法，1个普通的同步方法，一个对象，先打印 发短息？打电话？   打电话
 * 8.1个静态的同步方法，1个普通的同步方法，两个对象，先打印 发短息？打电话？   打电话
 */
public class Demo8 {
    public static void main(String[] args) {
        //两个对象的Class类模板，只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        new Thread(()->{phone1.sendSms();}).start();

        //睡眠1秒 捕获异常
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

}

class Phone3{
    /**
     * static 静态方法  类一加载就有了
     * 锁的是Class 模板
     * final Class<Phone2> phone2Class = Phone2.class; 这个Class静态对象，只有唯一一个。
     */
    public static synchronized void sendSms(){
        //睡眠1秒 捕获异常
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

}

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

6.集合类不安全

6.1ArrayList不安全

package org.sula.util;

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

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 10:44 上午
 * @Version: V1.0
 */
//java.util.ConcurrentModificationException  并发修改异常
public class Demo9 {
    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，读取的时候，固定的，写入（覆盖）
        //在写入的时候避免覆盖，造成数据问题。

        //读写分离   写入时，复制出来，写完后再插入进去。
        //CopyOnWriteArrayList 比 Vector好在哪里？   因为Vector的底层采用了synchronized，性能效率不高。而CopyOnWriteArrayList采用的Lock锁机制和复制原理。
        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();
        }
    }
}

请添加图片描述

6.2HashSet不安全

package org.sula.util;

import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 10:44 上午
 * @Version: V1.0
 */
//java.util.ConcurrentModificationException  并发修改异常
public class Demo10 {
    public static void main(String[] args) {
        /**
         * HashSet在多线程情况下线程不安全
         * 解决方案：
         * Set<String> set = Collections.synchronizedSet(new HashSet<>());
         * Set<String> set = new CopyOnWriteArraySet<>();
         */
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

6.3HashMap不安全

package org.sula.util;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 10:44 上午
 * @Version: V1.0
 */
//java.util.ConcurrentModificationException  并发修改异常
public class Demo11 {
    public static void main(String[] args) {

        /**
         * map 是这样用的吗？ 不是，工作中不用HashMap
         * 默认等价于什么？ new HashMap<>(16,0.75);
         * Map<String,String> map = new HashMap();
         */
         Map<String,String> map = new ConcurrentHashMap<>();

        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

7.Callable

1.可以有返回值
2.可以抛出异常
3.方法不同，run()/call()

package org.sula.util;

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

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 10:44 上午
 * @Version: V1.0
 */
//java.util.ConcurrentModificationException  并发修改异常
public class Demo12 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        new Thread(new MyThread()).start();
        MyThread myThread = new MyThread();
        FutureTask<String> stringFutureTask = new FutureTask<>(myThread);
        new Thread(stringFutureTask,"A").start();


        final String s = stringFutureTask.get();//可能会产生阻塞  把他放到最后   或者使用异步通信来处理
        System.out.println(s);

    }
}

//class MyThread implements Runnable{
//    @Override
//    public void run() {
//
//    }
//}

class MyThread implements Callable<String> {
    @Override
    public String call(){
        System.out.println("call()");
        return "hello";
    }
}

如果开两个线程启动
new Thread(stringFutureTask,“B”).start(); 结果会怎样呢？

注意：
1.有缓存
2.结果可能需要等待，有阻塞！

8.常用的辅助类

8.1.CountDownLatch（减法计数器）

package org.sula.util;

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 12:07 下午
 * @Version: V1.0
 */

import java.util.concurrent.CountDownLatch;

/**
 * 计数器  减法计数器
 */
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {

        //总数6  代表6个线程, 必须要执行任务的时候，再使用
        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();//等待计数器归0，再向下执行

        System.out.println("Close Door");
    }
}

请添加图片描述
原理：
countDownLatch.countDown(); //数量-1
countDownLatch.await();//等待计数器归0，再向下执行

每次有线程调用countDown数量-1，当计数器变为0时，await就会被唤醒，继续执行。

8.2.CyclicBarrier （加法计数器）

package org.sula.util;

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

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 12:17 下午
 * @Version: V1.0
 */
//加法计数器
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         * 集齐7颗龙珠召唤神龙
         */

        final 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();
        }


    }
}

请添加图片描述

小知识点：
在lambda表达式中是无法获取变量i的，需要借助中间参数final修饰。

8.3.Semaphore （信号量）

package org.sula.util;

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

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 12:28 下午
 * @Version: V1.0
 */
//抢车位  一共3个车位，6个车抢
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();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"归还车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

请添加图片描述

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

9.读写锁 ReadWriteLock

在这里插入图片描述
读可以被多个线程同时读，写的时候只能由一个线程去写。

package org.sula.util;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 2:22 下午
 * @Version: V1.0
 */

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        //写入
        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 ReentrantReadWriteLock 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);
            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);
        map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取Ok");
    }
}

请添加图片描述没有加锁的运行结果。

请添加图片描述
加锁后的运行结果。不被其他线程插入。

ReadWriteLock
读-读可以共存
读-写不能共存
写-写不能共存

独占锁（写锁）一次只能被一个线程占用
共享锁（读锁）可以由多个线程同时使用

10.阻塞队列

阻塞
队列请添加图片描述

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

学会使用队列

添加、移除

四组API
1、抛出异常
2、不会抛出异常
3、阻塞等待
4、超时等待

方式	抛出异常	有返回值,不抛异常	阻塞等待	超时等待
添加	add	offer	put	offer(“d”,2, TimeUnit.SECONDS)
移除	remove	poll	take	poll(2,TimeUnit.SECONDS)
判断队列首	element	peek	-	-

package org.sula.util;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 4:35 下午
 * @Version: V1.0
 */
public class Bq {

    public static void main(String[] args) throws InterruptedException {
        Bq bq = new Bq();
//        bq.test1();
//        bq.test2();
        bq.test3();
    }

    /**
     * 抛出异常
     */
    public 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"));

        //查看队首元素
        System.out.println(blockingQueue.element());

        // java.lang.IllegalStateException: Queue full  队列已满
//        System.out.println(blockingQueue.add("d"));

        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());

        //java.util.NoSuchElementException 队列没有了
//        System.out.println(blockingQueue.remove());
    }

    /**
     * 不抛出异常，携带返回值
     */
    public void test2(){
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("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
    }


    /**
     * 阻塞等待
     * @throws InterruptedException
     */
    public void test3() throws InterruptedException {
         ArrayBlockingQueue<Object> 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());  //阻塞
    }


    /**
     * 超时等待
     * @throws InterruptedException
     */
    public void test4() throws InterruptedException {
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("d",2, TimeUnit.SECONDS)); //等待2秒后，有则插，无则结束

        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(2,TimeUnit.SECONDS));//等待2秒，有则取，无则结束
    }
}

SynchronousQueue 同步队列

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

package org.sula.util;

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

/**
 * @PACKAGE_NAME: org.sula.util
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/14 5:03 下午
 * @Version: V1.0
 */
//同步队列
public class SynchronousQueueDemo {
    public static void main(String[] args) throws InterruptedException {
         SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>();
         new Thread(()->{
             try {
                 System.out.println(Thread.currentThread().getName()+"添加a");
                 synchronousQueue.put("a");
                 System.out.println(Thread.currentThread().getName()+"添加b");
                 synchronousQueue.put("b");
                 System.out.println(Thread.currentThread().getName()+"添加c");
                 synchronousQueue.put("c");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         },"T1").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"取出"+synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"取出"+synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"取出"+synchronousQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T2").start();

    }
}

请添加图片描述

11.线程池（重点）

线程池：三大方法、7大参数、4种拒绝策略

程序的运行，本质：占用系统资源！优化资源的使用！=》池化技术
线程池、连接池、内存池、对象池…
池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。

线程池的好处：
1.降低资源的消耗。
2.提高响应的速度。
3.方便管理。
线程复用，可以控制最大并发数，管理线程。

单个线程池/固定个数的线程池/可伸缩的线程池

package org.sula.pool;

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

/**
 * @PACKAGE_NAME: org.sula.pool
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/15 11:25 上午
 * @Version: V1.0
 */

/**
 * 使用线程池创建线程
 */
public class Demo1 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程池
        //以下方式可能会导致允许请求的队列长度Integer.MAX_VALUE太大，可能会堆积大量的请求，从而导致OOM.
//         ExecutorService threadPool = Executors.newFixedThreadPool(5);//固定5个线程池的大小
//        ExecutorService threadPool = Executors.newCachedThreadPool();//可伸缩的线程池。遇强则强，遇弱则弱。


        try {
            for (int i = 1; i <= 10; i++) {
                //使用线程池创建线程,创建线程
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //线程池使用完毕，需要关闭线程池
            threadPool.shutdown();
        }

    }
}

请添加图片描述

50个线程

newSingleThreadExecutor、newFixedThreadPool、newCachedThreadPool
以上方式可能会导致允许请求的队列长度Integer.MAX_VALUE太大，可能会堆积大量的请求，从而导致OOM内存溢出.

而这三种方法的底层实现都是采用 ThreadPoolExecutor，建议使用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;
    }

这个方法的7个参数

举例：
请添加图片描述

package org.sula.pool;

import java.util.concurrent.*;

/**
 * @PACKAGE_NAME: org.sula.pool
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/15 11:25 上午
 * @Version: V1.0
 */

/**
 * 使用线程池创建线程
 * 4.决绝策略
 * new ThreadPoolExecutor.AbortPolicy() //银行满了，还有人进来，不处理这个人的，抛出异常  java.util.concurrent.RejectedExecutionException
 * new ThreadPoolExecutor.CallerRunsPolicy() //哪来的去哪里  那个线程进来的  回哪个线程去执行   main
 * new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常
 * new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去获取最早的一个线程，如果尝试失败还是丢掉任务，不会抛出异常
 */
public class Demo1 {
    public static void main(String[] args) {
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程池
//         ExecutorService threadPool = Executors.newFixedThreadPool(5);//固定5个线程池的大小
//        ExecutorService threadPool = Executors.newCachedThreadPool();//可伸缩的线程池。遇强则强，遇弱则弱。

       ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去获取最早的一个线程，如果尝试失败还是丢掉任务，不会抛出异常
        );

        try {
            for (int i = 1; i <= 15; i++) {
                //使用线程池创建线程,创建线程
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //线程池使用完毕，需要关闭线程池
            threadPool.shutdown();
        }

    }
}

小结和策略：

线程池的最大线程数如何设置？
1.CPU 密集型。几核，就是几，可以保持CPU的效率最高！通过代码去获取CPU核数。 Runtime.getRuntime().availableProcessors()
2.IO 密集型。判断程序中十分耗IO的线程个数，设置>此个数就好了

12.四大函数式接口（必需掌握）

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

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

//超级多 @FunctionalInterface
//简化编程模式，在新版本的底层大量应用！
//foreach(消费着类型的函数式接口)

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

四大原生函数式接口 在这里插入图片描述

1.Function 函数式接口

//函数式接口
//         Function<String, String> function = new Function<String, String>() {
//            @Override
//            public String apply(String s) {
//                return null;
//            }
//        };


 //只要是函数式接口 可以用 lambda表达式简化
Function<String, String> function = (str)->{return str;};

System.out.println(function.apply("hahah"));

2.Predicate 断定型接口

      //断定型接口：有一个输入参数，返回值只能是布尔值
//        final 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("hahahah"));

3.Consumer消费型接口

//消费性接口  只有输入，没有返回值
//        final Consumer<String> con = new Consumer<String>() {
//            @Override
//            public void accept(String o) {
//                
//            }
//        };

  Consumer<String> con = (s)->{System.out.println(s);};

4.Supplier 供给型接口

//供给型接口  没有输入，只有返回值
//        final Supplier<String> sup = new Supplier<String>() {
//            @Override
//            public String get() {
//                return "hhhh";
//            }
//        };
        
Supplier<String> sup = ()->{return "hhhh";};

12.2 Stream流式计算

package org.sula.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @PACKAGE_NAME: org.sula
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/15 2:41 下午
 * @Version: V1.0
 */
public class stream {
    public static void main(String[] args) {

        /**
         * 要求：一分钟内完成此题，用一行代码实现。
         * 1.ID必须是偶数
         * 2.年龄必须大于23岁
         * 3.用户名转为大写字母
         * 4.用户名倒叙
         * 5.只输出一个用户
         */
        final User u1 = new User(1, "a", 20);
        final User u2 = new User(2, "b", 21);
        final User u3 = new User(3, "c", 23);
        final User u4 = new User(4, "d", 24);
        final User u5 = new User(5, "e", 26);

        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);

		//lambda表达式，链式编程，函数式接口，Stream流式计算
        list.stream()
                .filter(u->u.getId()%2==0&&u.getAge()>23)
                .map(u->u.getName().toUpperCase())
                .sorted((a,b)->{return b.compareTo(a);})
                .limit(1)
                .forEach(System.out::println);
    }
}


@Data
class User {
    private Integer id;
    private String name;
    private Integer age;

    public User(Integer id,String name,Integer age){
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

14.ForkJoin

什么是ForkJoin
ForkJoin在JDK1.7，并行执行任务！提高效率，大数据量！
大数据库：Map Reduce（把大任务拆分为小任务）
请添加图片描述
**ForkJoin 工作窃取。**里面维护的都是双端队列

举例：计算求和

package org.sula.stream;

import java.util.concurrent.RecursiveTask;


/**
 * @PACKAGE_NAME: org.sula.stream
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/15 3:10 下午
 * @Version: V1.0
 */

/**
 * 求和计算的任务
 * 3000  6000(ForkJoin)  9000(Stream并行流)
 *
 * 如何使用ForkJoin
 * 1.ForkJoinPool 通过他来执行
 * 2.计算任务ForkJoinPool.execute(ForkJoinTask<?> task)
 * 3.计算类需要继承RecursiveTask
 */
public class ForkJoinDemo extends RecursiveTask<Long> {

    private Long start;
    private Long end;

    private Long temp = 10000L;

    //commond+n 快捷键生成构造器
    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 += i;
           }
           return sum;
       }else {
           Long middle = (start+end)/2;//中间值
           final ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
           task1.fork();//拆分任务，把任务压入队列
           final ForkJoinDemo task2 = new ForkJoinDemo(middle, end);
           task2.fork();

           return task1.join()+task2.join();
       }
    }



    public static void main(String[] args) {

    }

}

package org.sula.stream;

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

/**
 * @PACKAGE_NAME: org.sula.stream
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/15 3:40 下午
 * @Version: V1.0
 */
public class Test {

    @org.junit.jupiter.api.Test
    public void test1(){
        final long start = System.currentTimeMillis();
        //传统 3000
        Long sum = 0L;
        for (Long i = 1L; i <= 10_0000_0000L ; i++) {
            sum += i;
        }
        System.out.println(sum);

        final long end = System.currentTimeMillis();
        System.out.println("test1==>"+sum+">===使用"+(end-start)+"秒");
    }

    @org.junit.jupiter.api.Test   //3799秒
    public void test2() throws ExecutionException, InterruptedException {
        final long start = System.currentTimeMillis();
        final ForkJoinPool forkJoinPool = new ForkJoinPool();
        final ForkJoinTask<Long> task = new ForkJoinDemo(0L,10_0000_0000L);
//        forkJoinPool.execute(task);//同步方法
        final ForkJoinTask<Long> submit = forkJoinPool.submit(task);//异步方法
        Long sum = submit.get();
        final long end = System.currentTimeMillis();
        System.out.println("test2==>"+sum+">===使用"+(end-start)+"秒");
    }


    @org.junit.jupiter.api.Test  //181秒
    public void test3(){
        final long start = System.currentTimeMillis();

        //LongStream
        //range()  () 不带开头结尾的
        //rangeClosed()  (] 带结尾的
        //parallel  并行计算
        //

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

        final long end = System.currentTimeMillis();
        System.out.println("test3==>"+sum+">===使用"+(end-start)+"秒");
    }
}

15.异步回调

14.1 异步没有返回值

//没有返回值的 runAsync  异步回调
 final CompletableFuture<Void> objectCompletableFuture = CompletableFuture.runAsync(()->{
     try {
         TimeUnit.SECONDS.sleep(2);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
     System.out.println(Thread.currentThread().getName()+"runAsync==>Void");
 });

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

14.1 异步有返回值

//有返回值得异步回调
final CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
    System.out.println(Thread.currentThread().getName() + "supplyAsync==>Integer");
//  int i = 10/0;//写一个错误测试
    return 1024;
});

integerCompletableFuture.whenComplete((t,u)->{
    //回调成功
    System.out.println("t====>"+t);
    System.out.println("u====>"+u);
}).exceptionally((e)->{
    //回调失败
    e.getMessage();
    return 233;
}).get();

16.JMM

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

什么是JMM？
JMM：java内存模型，不存在的东西，是一个概念、约定。
关于JMM的一些同步的约定：
1.线程解锁前，必须把共享变量 “立刻”刷回主存。
2.线程加锁前，必须读取主存中的最新值到工作内存中。
3.加锁和解锁必须是同一把锁。

请添加图片描述
内存交互操作有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操作之前，必须把此变量同步回主内存

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

            }
        }).start();

        TimeUnit.SECONDS.sleep(2);

        num = 1;
        System.out.println(num);
    }
}

请添加图片描述
此时结果，程序不会停止。因为新开启的线程，不知道主线程已经更改了num的值。无法获取。

如何解决呢？ Volatile

16.Volatile

1.保证可见性

private volatile static int num = 0;
综上，加上volatile后，程序num=1后，程序立马停止。

2.不保证原子性

public class VolatileDemo {
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
//        num++;   //不是一个原子性操作   原子性操作就是唯一的，不会被中途插入中断的操作
        num.getAndIncrement();  //+1  底层采用CAS
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 1; j <= 100; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount() > 2){ //main gc
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"===>"+num);
    }
}

如果不采用lock、synchronized，那么Volatile及时加上也无法实现正确的2000结果。顾我们采用 java.util.concurrent.atomic包下的原子类，即可，并且其性能要高于lock、synchronized

因为这些类的底层是直接操作操作系统的。

3.禁止指令重排

什么是指令重排：程序执行并不像我们想象中的写的方式去执行的。
源代码->编译器优化重排->指令并行重排->内存系统重排->执行

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

 int x = 1;//1
 int y = 2;//2
 x = x + 5;//3
 y = x * x;//4
 我们期望的执行是1234，但可能会是2134、1324
 但不可能是4321。

举例：
x=0,y=0,a=0,b=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是可以保证可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排。

17.彻底玩转单例模式

恶汉式，DCL懒汉式，深究。

17.1 恶汉式

package org.sula.single;

/**
 * @PACKAGE_NAME: org.sula.single
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/16 9:40 上午
 * @Version: V1.0
 */

/**
 * 饿汉式单例
 *
 * 有可能会浪费内存
 *
 * 没有使用，就已经创建了
 */
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];

    //私有构造器  其他类无法new
    private Hungry(){

    }

    private final static Hungry hungry = new Hungry();

    public static Hungry getInstance(){
        return hungry;
    }
}

17.2 DCL懒汉式（推荐）

package org.sula.single;

/**
 * @PACKAGE_NAME: org.sula.single
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/16 9:53 上午
 * @Version: V1.0
 */
![请添加图片描述](https://img-blog.csdnimg.cn/201bcae5f96748fc854ae91e81122750.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAU3VsYXM=,size_20,color_FFFFFF,t_70,g_se,x_16)

import java.lang.reflect.Constructor;

/**
 * DCL懒汉式单例
 * 1.使用synchronized 加锁class模板
 * 2.初始化对象加上volatile  保证不会出现指令重排
 *
 * 使用的时候再去创建
 */
public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }

    private volatile static LazyMan lazyMan;

    //此方法 单线程下没有问题，但如果使用多线程则会出现问题
//    public static LazyMan getInstance() {
//        if (lazyMan == null) {
//            lazyMan = new LazyMan();//不是原子性操作
//        }
//        return lazyMan;
//    }

    public static LazyMan getInstance(){
        if(lazyMan == null){
            synchronized (LazyMan.class){
                if(lazyMan == null){
                    lazyMan = new LazyMan();//不是原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个额对象指向这个空间
                     *
                     * 123
                     * 132 A  //指令重排
                     *     B //此时lazyMan还没有完成构造
                     */
                }
            }
        }
        return lazyMan;
    }


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

	//反射可以破坏这种单例
    public static void main(String[] args) throws Exception {
        final LazyMan instance = LazyMan.getInstance();
        final Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);//无视私有构造器
        //反射区创建单例
        final LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }


}

单例不安全，因为有反射
我们使用反射打印出来的结果：不难可以看出，两个单例，已经不是同一个对象了。那如何解决这个问题呢？Enum
请添加图片描述

17.3 静态内部类

package org.sula.single;

/**
 * @PACKAGE_NAME: org.sula.single
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/16 10:03 上午
 * @Version: V1.0
 */

/**
 * 静态内部类
 */
public class Holder {

    private Holder(){

    }

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

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

单例不安全，因为有反射

17.4 枚举

package org.sula.single;

/**
 * @PACKAGE_NAME: org.sula.single
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/16 10:26 上午
 * @Version: V1.0
 */

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

/**
 * 枚举单例
 */
public enum  EnumSingle {
    INATANCE;

    public EnumSingle getInatance(){
        return INATANCE;
    }
}


class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        final EnumSingle inatance = EnumSingle.INATANCE;
        final Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        final EnumSingle inatance1 = declaredConstructor.newInstance();


        System.out.println(inatance);
        System.out.println(inatance1);
    }
}

查看反编译代码后，我们发现枚举存在一个无参构造器。
EnumSingle.class.getDeclaredConstructor(null); 请添加图片描述
执行后发现，提示我们不存在无参构造器。

于是我们采用更专业的反编译工具，jad去反编译class文件后发现，构造器存在两个参数，一个String，Int。
EnumSingle.class.getDeclaredConstructor(String.class,int.class);
修改后，执行结果。请添加图片描述
发现结果确实跟我们newInstance方法点进去的源码提示相同。

结论，枚举创建的单例是不能被反编译的。

18.深入理解CAS

请添加图片描述

final AtomicInteger atomicInteger = new AtomicInteger(2020);
//期望，更新
//如果期望的值达到了，那么就更新，否则，不更新
//compareAndSet  比较并交换
System.out.println(atomicInteger.compareAndSet(2020, 2021));//true
System.out.println(atomicInteger.get());

atomicInteger.getAndIncrement(); //+1
System.out.println(atomicInteger.compareAndSet(2020, 2021));//false
System.out.println(atomicInteger.get());

CAS:比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！（自旋锁）
缺点：
1.循环会耗时，但是相对java来说好多了
2.一次性只能保证一个共享变量的原子性（足以满足）
3.ABA问题

CAS问题：ABA问题（狸猫换太子）

19.原子引用

带版本号的原子操作！
integer使用了对象缓存机制，默认范围-128~127，推荐使用静态工厂方法valueOf获取对象实例，而不是new，因为valueof使用缓存，而new一定会创建新的对象分配新的内存空间。
请添加图片描述

 final AtomicStampedReference<Integer> integerAtomicReference = new AtomicStampedReference<Integer>(1,1);
        
        new Thread(()->{
            final int stamp = integerAtomicReference.getStamp();
            //打印版本号
            System.out.println("a1=>"+stamp);

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

            System.out.println(integerAtomicReference.compareAndSet(1, 2,
                    stamp, stamp + 1));

            System.out.println("a2=>"+integerAtomicReference.getStamp());


            System.out.println(integerAtomicReference.compareAndSet(2, 1,
                    integerAtomicReference.getStamp(), integerAtomicReference.getStamp() + 1));

            System.out.println("a3=>"+integerAtomicReference.getStamp());

        },"a").start();
        
        
        new Thread(()->{
            final int stamp = integerAtomicReference.getStamp();
            //打印版本号
            System.out.println("b1=>"+stamp);


            System.out.println(integerAtomicReference.compareAndSet(1, 666,
                    integerAtomicReference.getStamp(), integerAtomicReference.getStamp() + 1));

            System.out.println("b2=>"+integerAtomicReference.getStamp());

        },"b").start();

20.各种锁的理解

20.1 公平锁、非公平锁

公平锁：不允许插队，必须先来后到，按顺序来！
非公平锁：可以插队。（默认非公平锁）

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

20.1 可重入锁(递归锁)

package org.sula.lock;

/**
 * @PACKAGE_NAME: org.sula.lock
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/16 12:11 下午
 * @Version: V1.0
 */

//synchronized  非公平锁
public class LockDemo {
    public static void main(String[] args) {
        final 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");
    }
}

请添加图片描述
按照结果来看，执行第一个线程，调用完sms方法后并没有释放锁。

lock版本的

package org.sula.lock;

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

/**
 * @PACKAGE_NAME: org.sula.lock
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/16 12:11 下午
 * @Version: V1.0
 */

//synchronized  非公平锁
public class LockDemo {
    public static void main(String[] args) {
        final Phone phone = new Phone();
        new Thread(()->{
            phone.sms();
        },"A").start();

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

class Phone{
    private Lock lock = new ReentrantLock();
    public void sms(){
        lock.lock();//lock锁必须配对，加锁解锁成对出现。 否则会造成死锁
        try {
            System.out.println(Thread.currentThread().getName() + "sms");
            call();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }

    }

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

注意：lock锁必须配对，加锁解锁成对出现。否则会造成死锁

20.1 自旋锁

自定义自旋锁，类似ReentrantLock

package org.sula.lock;

/**
 * @PACKAGE_NAME: org.sula.lock
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/16 12:25 下午
 * @Version: V1.0
 */

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinLock {

   private AtomicReference reference = new AtomicReference();

   public void myLock(){
       final Thread thread = Thread.currentThread();
       System.out.println(thread.getName()+"=>myLock");
       while (!reference.compareAndSet(null,thread)){

       }
   }

    public void myUnLock(){
        final Thread thread = Thread.currentThread();
        System.out.println(thread.getName()+"=>myUnLock");
        reference.compareAndSet(thread,null);
    }
}


class Test{
    public static void main(String[] args) throws InterruptedException {
        //a，b两个线程。    //b会等待a执行完成解锁，b才能解锁
        SpinLock lock = new SpinLock();
        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.myUnLock();
            }
        },"a").start();

        TimeUnit.SECONDS.sleep(1);//需要等待

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

    }
}

20.1 死锁

请添加图片描述
不同的锁对象，抢夺对方锁资源，造成死锁。

package org.sula.lock;

import java.util.concurrent.TimeUnit;

/**
 * @PACKAGE_NAME: org.sula.lock
 * @Description:
 * @Author: liangxu
 * @Date: 2021/9/16 2:25 下午
 * @Version: V1.0
 */
public class dedDemo {
    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{

    String lockA;
    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);
            }
        }
    }
}