JUC 并发编程

_子栖_

已于 2023-06-27 14:21:20 修改

阅读量685

点赞数

分类专栏： Java 文章标签： juc

于 2020-12-15 16:18:01 首次发布

本文链接：https://blog.csdn.net/yao_wen_yu/article/details/109569589

版权

Java 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

JUC 并发编程

1、什么是JUC

在这里插入图片描述
java.util 工具包、包、分类

2、线程和进程

线程和进程，如果不能使用一句话说出来的技术，就是不扎实！

进程：一个程序，QQ.exe
一个进程往往包含多个线程
java默认有几个线程？ 2个 main线程，GC线程
线程：程序执行的最小单元

java真的能开启线程吗？ 开不了

只能通过调用本地方法，java无法直接操作硬件

并发、并行

并发编程：并发、并行
并发（多线程操作同一资源）
并行（多个人一起行走），多个线程可以同时执行 线程池
并发编程的本质：充分利用CPU的资源

线程状态：

public enum State {
       //新生
        NEW,

       //运行
        RUNNABLE,

       //阻塞
        BLOCKED,

       //等待
        WAITING,

        //超时等待
        TIMED_WAITING,

        //终止
        TERMINATED;
    }

wait() 与 sleep() 区别
1、来自不同的类
wait => Object
sleep => Thread
2.关于锁的释放
wait会释放锁，sleep不会释放锁
3.使用范围
wait
同步代码块、同步方法
sleep
任何地方
4.是否需要捕获异常
wait不需要捕获（中断异常）
sleep需要捕获

3、Lock（重点）

传统的Synchronized

/**
 * 公司中的多线程开发
 *线程就是一个资源类，没有任何附属操作
 * 属性、方法
 */
public class SaleTicket {
    public static void main(String[] args) {
        //并发操作
        MyTicket myTicket = new MyTicket();
        new Thread(()->{
            for(int i=0;i<60;i++){
                myTicket.sale();
            }
        },"A").start();
        new Thread(()->{
            for(int i=0;i<60;i++){
                myTicket.sale();
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<60;i++){
                myTicket.sale();
            }
        },"C").start();
    }
}
class MyTicket{
    private int tickets = 50;

    public synchronized void sale(){
        if (tickets > 0){
            System.out.println(Thread.currentThread().getName()+"卖出票号为"+(tickets--)+"剩余："+tickets);
        }
    }

    //锁  对象  class
}

Lock 接口

在这里插入图片描述

公平锁：十分公平：可以先来后到
非公平锁：十分不公平：允许插队（默认）

public class SaleTicket2 {
    public static void main(String[] args) {
        //并发操作
        MyTicket2 myTicket = new MyTicket2();
        new Thread(()->{for(int i=0;i<60;i++)myTicket.sale();},"A").start();
        new Thread(()->{for(int i=0;i<60;i++)myTicket.sale();},"B").start();
        new Thread(()->{for(int i=0;i<60;i++)myTicket.sale();},"C").start();
    }
}

class MyTicket2{
    private int tickets = 50;

    Lock lock = new ReentrantLock();

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

Synchronized 和 Lock 区别

1.Synchronized 内置关键字,Lock 是一个类
2.Synchronized 无法判断获取锁的状态,Lock 可以判断是否获取到了锁
3.Synchronized 会自动释放锁,Lock不会释放锁, 死锁
4.Synchronized 会造成阻塞，Lock锁不会阻塞（lock.tryLock()）
5.Synchronized 可重入锁，不可以中断，非公平锁，Lock 可重入锁，可以判断锁，非公平的（可以设置）
6.Synchronized 适合锁少量代码，Lock可以锁大量的代码

4、生产者和消费者

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

生产者和消费者 Synchronized 版、wait notify

/**
 * 线程之间的通信问题：生产者和消费者问题！等待唤醒，通知唤醒
 * 线程交替执行 A  B  操作同一变量  num=0
 * A  num+1
 * B  num-1
 */

public class Demo7 {

    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i=0;i<5;i++){
                try {
                    data.incre();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i =0;i<5;i++){
                try {
                    data.decre();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

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

    //+1
    public synchronized void incre() throws InterruptedException {
        if (number != 0){
            //等待操作
            this.wait();
        }
        number ++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，+1操作完成
        this.notifyAll();
    }
    //-1
    public synchronized void decre() throws InterruptedException {
        if (number == 0){
            //等待操作
            this.wait();
        }
        number --;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，-1操作完成
        this.notifyAll();
    }
}

如果有四个线程呢，两个加两个减。===》出错了
在这里插入图片描述

在这里插入图片描述
将 if 判断改为 while 判断

/**
 * 线程之间的通信问题：生产者和消费者问题！等待唤醒，通知唤醒
 * 线程交替执行 A  B  操作同一变量  num=0
 * A  num+1
 * B  num-1
 */

public class Demo7 {

    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i=0;i<5;i++){
                try {
                    data.incre();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i=0;i<5;i++){
                try {
                    data.incre();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i =0;i<5;i++){
                try {
                    data.decre();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i =0;i<5;i++){
                try {
                    data.decre();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

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

    //+1
    public synchronized void incre() throws InterruptedException {
        while (number != 0){
            //等待操作
            this.wait();
        }
        number ++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，+1操作完成
        this.notifyAll();
    }
    //-1
    public synchronized void decre() throws InterruptedException {
        while (number == 0){
            //等待操作
            this.wait();
        }
        number --;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，-1操作完成
        this.notifyAll();
    }
}

JUC版生产者和消费者

通过Lock 找到 Condition
在这里插入图片描述
代码实现

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

public class Demo9{
    public static void main(String[] args) {
    Data2 data2 = new Data2();
        new Thread(()->{
            for (int i=0;i<5;i++){
                data2.incre();
            }
        },"A").start();
        new Thread(()->{
            for (int i=0;i<5;i++){
                data2.incre();
            }
        },"C").start();
        new Thread(()->{
            for (int i=0;i<5;i++){
                data2.decre();
            }
        },"B").start();
        new Thread(()->{
            for (int i=0;i<5;i++){
                data2.decre();
            }
        },"D").start();
    }
}

//  判断等待、业务、通知
class Data2{    //数字，资源类
    private int  number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();


    //+1
    public void incre(){
        lock.lock();
        try {
            while (number != 0){
                //等待操作
                condition.await();  //等待
            }
            number ++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，+1操作完成
            condition.signalAll();  //唤醒全部
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    //-1
    public void decre() {
        lock.lock();
        try {
            while (number == 0){
                //等待操作
                condition.await();
            }
            number --;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，-1操作完成
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Condition 精准通知和唤醒功能

代码测试

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 Demo10 {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printC();
            }
        },"C").start();
    }
}
class Data3{  //资源类
    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()+"->BBBB->执行了");
            number = 3;
            //唤醒指定的  C
            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()+"->CCCC->执行了");
            number = 1;
            condition1.signal();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

5、8锁现象

锁是什么？如何判断锁的是谁？
锁对象锁Class


import java.util.concurrent.TimeUnit;

/**
 * 8锁就是关于锁的 8个问题
 * 1.标准情况下，两个线程先打印发短信还是打电话   1/发短信  2/打电话
 * 2.sendSms方法延迟4s，两个线程先打印发短信还是打电话   1/发短信  2/打电话
 *
 */
public class Demo11 {
    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.sendCall();
        },"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 sendCall(){
        System.out.println("打电话");
    }
}

import java.util.concurrent.TimeUnit;

/**
 * 8锁就是关于锁的 8个问题
 * 3.增加了一个普通方法，发短信还是hello
 * 4.两个对象，两个同步方法    先执行发短信还是打电话
 */
public class Demo12 {
    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.sendCall();
        },"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 sendCall(){
        System.out.println("打电话");
    }

    //这里面没有锁，不受锁的影响
    public void hello(){
        System.out.println("Hello");
    }
}

import java.util.concurrent.TimeUnit;

/**
 * 8锁就是关于锁的 8个问题
 * 5.增加两个静态的同步方法  先打印发短信还是打电话 ?
 * 6.两个对象  增加两个静态的同步方法  先打印发短信还是打电话 ?
 */
public class Demo13 {
    public static void main(String[] args) {
        //两个对象，两个调用着，两把锁
        //两个对象的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.sendCall();
        },"B").start();

    }
}

//Phone 唯一的一个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 sendCall(){
        System.out.println("打电话");
    }

}

import java.util.concurrent.TimeUnit;

/**
 * 8锁就是关于锁的 8个问题
 * 7.一个静态同步方法，一个普通同步方法 一个对象  先打印发短信还是打电话 ?
 * 8.一个静态同步方法，一个普通同步方法 两个对象  先打印发短信还是打电话 ?
 */
public class Demo14 {
    public static void main(String[] args) {

        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.sendCall();
        },"B").start();

    }
}

//Phone 唯一的一个Class对象
class Phone4{

    //synchronized  锁的对象时方法的调用者！
    //静态同步方法   锁的是Class 类模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通同步方法  锁的是调用者
    public synchronized void sendCall(){
        System.out.println("打电话");
    }

}

小结

一个对象里面如果有多个 synchronized 方法，某一时刻内，只要一个线程去调用其中的一个 synchronized 方法了，其他线程都只是等待，换句话说，某一时刻，只能有唯一一个线程去访问这些 synchronized 方法，锁的是当前对象 this ，被锁定后，其他线程都不能进入到当前对象的其他 synchronized 方法。

加个普通方法后发现和同步锁无关

换成两个对象后，不是同一把锁了，情况立刻变化。

都换成静态同步方法之后，情况又变化

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

所有的非静态同步方法用的都是同一把锁-------实例对象本身。

synchronized 实现同步的基础：java 中的每一个对象都可以作为锁。
具体变现一下三种形式：
对于普通同步方法，锁是当前实例对象
对于静态同步方法，锁是当前类的 class 对象
对于同步方法块，锁的是 synchronized 括号里面的配置对象

当一个线程试图访问同步代码块时，他首先必须得到锁，退出或抛出异常时必须释放锁。
也就是说，如果一个实例对象的非静态同步方法获取到锁之后，该实例对象的其他非静态同步方法必须等到获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以无须等待该实例对象以获取锁的非静态同步方法释放锁就可以获取他们自己的锁了。

所有的静态同步方法用的都是同一把锁-------类对象本身。
这两把锁是两个不同的对象所以静态同步方法与费静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取到锁之后，其他的静态同步方法都必须等到该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同实例对象的静态同步方法之间，只要他们是同一个类的实例对象！

6、集合类不安全

List 不安全

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

// java.util.ConcurrentModificationException  并发修改异常
public class ListTest {
    public static void main(String[] args) {
        //并发下 ArrayList不安全
        /**
         * 解决方案
         * 1. List<String> strings = new Vector<>();
         * 2. List<String> strings =Collections.synchronizedList(new ArrayList<>());
         * 3. List<String> strings = new CopyOnWriteArrayList<>();
         */

        //CopyOnWriteArrayList  写入时复制  简称 COW 计算机程序设计领域的一种优化策略
        // 多线程调用的时候，list 读取的时候是固定的，写入（覆盖）
        //写入的时候避免覆盖造成数据问题
        //CopyOnWriteArrayList（lock锁） 比 Vector（Synchronized） 好
        List<String> strings = new CopyOnWriteArrayList<>();
        for (int i = 1; i <=10 ; i++) {
            new Thread(()->{
                strings.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(strings);
            },String.valueOf(i)).start();
        }

    }
}

Set 不安全

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

/**
 * 同理可证：java.util.ConcurrentModificationException
 * 解决方案:
 * 1.Collections.synchronizedSet(new HashSet<>());
 * 2.Set<String> set = new CopyOnWriteArraySet();
 */
public class SetTest {
    public static void main(String[] args) {
//        Set<String> set = new HashSet<>();
//        Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set = new CopyOnWriteArraySet();
        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底层是什么？
在这里插入图片描述
add方法 set本质就是map 的key 是无法重复的

在这里插入图片描述
persent是一个固定的值

Map 不安全

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

// ConcurrentModificationException  并发修改异常
public class MapTest {
    public static void main(String[] args) {
        //map是这样用的吗 ？  不是 工作中不用 HashMap
        // 默认等价于什么？  new HashMap<>(16,0.75);
        //Map<String, String> map = new HashMap<>();

        /** 解决方案:
         * 1. Collections.synchronizedMap(new HashMap<>());
         * 2. 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 底层原理

在JDK1.7中，ConcurrentHashMap的数据结构是由一个Segment数组和多个HashEntry组成，如下图所示：
在这里插入图片描述

Segment数组的意义就是将一个大的table分割成多个小的table来进行加锁，也就是上面的提到的锁分离技术，而每一个Segment元素存储的是HashEntry数组+链表，这个和HashMap的数据存储结构一样

7、Callable（简单）

在这里插入图片描述

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

代码测试

在这里插入图片描述

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 MyThread()).start();
        // new Thread().start();   //如何启动callable()
        MyThread myThread = new MyThread();
        //适配类
        FutureTask futureTask = new FutureTask(myThread);
        new Thread(futureTask,"线程A").start();   //如何启动callable()
        new Thread(futureTask,"线程B").start();
        String  string = (String) futureTask.get();  //获取callable的返回结果
        System.out.println(string);
    }
}

class MyThread implements Callable<String> {

    @Override
    public String call() throws Exception {
        return "ABC";
    }
}

细节：

有缓存
结果可能需要等待，会阻塞！

8、常用的辅助类

8.1 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(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"走了");
                    countDownLatch.countDown();
                }
            },String.valueOf(i)).start();
        }
       countDownLatch.await(); //等待计数器归零，向下执行
       System.out.println("关门");
    }
}

原理：

countDownLatch.countDown(); //数量减一
countDownLatch.await(); //等待计数器归零，向下执行
每次有线程调用countDown()数量减一，假设数量变为0，countDownLatch.await() 就会被唤醒，向下执行

8.2 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;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"集齐"+temp+"颗龙珠");
                    try {
                        cyclicBarrier.await();   //等待计数器变为 7
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            },String.valueOf(i)).start();
        }
    }
}

8.3 Semaphore （信号量）

在这里插入图片描述

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(5);   //线程数量
        for (int i = 1; i <= 10 ; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //得到车位
                    try {
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName()+"拿到了车位");
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        //释放车位
                        semaphore.release();
                        System.out.println(Thread.currentThread().getName()+"离开了车位");
                    }


                }
            },String.valueOf(i)).start();
        }

    }
}

原理：

semaphore.acquire(); //获得许可，假设如果满了，等待，直到被释放为止
semaphore.release(); //释放许可，会见当前的信号量释放
作用：
多个共享资源的互斥使用，并发限流
控制最大的线程数

9、读写锁

ReadWriterLock

在这里插入图片描述

/**
 * 独占锁：WriteLock
 * 共享锁：ReadLock
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {

        MyCache myCache = new MyCache();

        MyCacheLock myCacheLock = new MyCacheLock();

        //写入操作
        for (int i = 1; i <= 5 ; i++) {
            final int tmp = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    myCacheLock.put(tmp+"",tmp);
                }
            },String.valueOf(i)).start();
        }


        //读取操作
        for (int i = 1; i <= 5 ; i++) {
            final int tmp = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    myCacheLock.get(tmp+"");
                }
            },String.valueOf(i)).start();
        }
    }
}

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

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

    //取数据
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取数据");
        map.get(key);
    }
}

/**
 * 自定义缓存加锁
 */
class MyCacheLock{
    private volatile Map<String,Object> map = new HashMap<>();
    //读写锁
    ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    //存数据  ，只希望同时只有一个线程写入
    public void put(String key,Object obj){
        reentrantReadWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"写入数据");
            map.put(key, obj);
            System.out.println(Thread.currentThread().getName()+"写入数据OK");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            reentrantReadWriteLock.writeLock().unlock();
        }
    }

    //取数据 ，允许多个线程读取
    public void get(String key){
        reentrantReadWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读取数据");
            map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取数据OK");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            reentrantReadWriteLock.readLock().unlock();
        }
    }
}

10、阻塞队列

FIFO（先进先出）
写入（如果队列满了，就必须阻塞等待）
读取（如果队列是空的，就必须阻塞等到生产）

在这里插入图片描述

BlockQueue

什么情况下会使用阻塞队列？多线程并发处理，线程池
学会使用队
添加、移除
四组API

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

//阻塞队列
public class BlockQueueDemo {
    public static void main(String[] args) {
        test1();
    }
    //抛出异常
    public static void test1(){
        //队列的大小
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(arrayBlockingQueue.add("a"));
        System.out.println(arrayBlockingQueue.add("b"));
        System.out.println(arrayBlockingQueue.add("c"));
        //java.lang.IllegalStateException: Queue full  抛出异常
        //System.out.println(arrayBlockingQueue.add("d"));
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        //java.util.NoSuchElementException  抛出异常 没有元素
        System.out.println(arrayBlockingQueue.remove());

    }
}

 //不抛出异常
    public static void test2(){
        //队列的大小
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);

        //存数据
        System.out.println(arrayBlockingQueue.offer("a"));
        System.out.println(arrayBlockingQueue.offer("b"));
        System.out.println(arrayBlockingQueue.offer("c"));

        System.out.println(arrayBlockingQueue.offer("D"));  //false 不抛出异常！

        //取数据
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());   //null 不抛出异常

    }

/**
     * 等待，阻塞（一直阻塞）
     */
    public static 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());   //没有这个元素,一直阻塞
    }

 /**
     * 等待，阻塞（等待超时）
     */
    public static void test4() throws InterruptedException {
        ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        blockingQueue.offer("D",2,TimeUnit.SECONDS);

        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 () get()

public class SynchronousQueueDemo {
    public static void main(String[] args) {
        SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>();  //同步队列，没有容量
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"-->put 1");
                synchronousQueue.put("1");
                System.out.println(Thread.currentThread().getName()+"-->put 2");
                synchronousQueue.put("2");
                System.out.println(Thread.currentThread().getName()+"-->put 3");
                synchronousQueue.put("3");
            } 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());
                synchronousQueue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"t2").start();
    }
}

11、线程池（重点）

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

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

线程池的好处
1、降低资源的消耗
2、提高响应的速度
3、方便管理

线程复用、可以控制最大并发数、管理线程
在这里插入图片描述

线程池的三大方法

//工具类
public class ThreadPoolDemo {
    public static void main(String[] args) {
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程池
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);//创建一个固定线程池的大小
        ExecutorService threadPool = Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱

        try {
            for (int i = 1; i <= 100 ; i++) {
                // new Thread(()->{},String.valueOf(i)).start();   //传统方式
                //使用了线程池，就使用线程池方式创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池使用完毕，就要关闭线程池
            threadPool.shutdown();
        }
    }
}

7大参数

源码分析

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

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,   //约等于21亿
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    
// 本质：开启线程池调用的是ThreadPoolExector
//所谓的7大参数
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;
    }

在这里插入图片描述
超时等候时间

手动创建一个线程池

public class MyThreadPoolExecutorDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,  //最小线程数
                5, //最大处理并发数
                3, //
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),  //相当于银行候客区
                Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy() // 银行满了，但是还有人进来，不处理这个人，就抛出异常
//                new ThreadPoolExecutor.CallerRunsPolicy()  //哪来的去哪里，
//                new ThreadPoolExecutor.DiscardPolicy()  //队列满了，不会抛出异常，会丢掉任务
                new ThreadPoolExecutor.DiscardOldestPolicy()  //队列满了，尝试去和最早的竞争，也不会抛出异常
                );

        try {
            //最大承载数 = 队列容量 + 最大线程数
            //超出最大承载
            for (int i = 1; i <= 9 ; i++) {
                threadPoolExecutor.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"==>ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPoolExecutor.shutdown();
        }
    }
}

四种拒绝策略

   new ThreadPoolExecutor.AbortPolicy() // 银行满了，但是还有人进来，不处理这个人，就抛出异常
   new ThreadPoolExecutor.CallerRunsPolicy()  //哪来的去哪里，
   new ThreadPoolExecutor.DiscardPolicy()  //队列满了，不会抛出异常，会丢掉任务
   new ThreadPoolExecutor.DiscardOldestPolicy()  //队列满了，尝试去和最早的竞争，也不会抛出异常

小结和拓展
自定义线程池的最大线程到底该如何定义？

CPU密集型几核，就是几，可以保证CPU的效率最高

System.out.println(Runtime.getRuntime().availableProcessors()); //获取CPU的核数

IO密集型判断你程序中十分耗IO的线程，一般设置为 2倍。

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

lambda表达式、链式编程、函数式接口、Stream流计算

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

简化编程模型，在新版本的框架中大量使用
foreach（）参数就是一个消费者函数式接口

Function

在这里插入图片描述

public class FunctionDemo {
    public static void main(String[] args) {

        //工具类：输出输入的值
        /**
         * 特性：有一输入参数，有一个输出参数
         *      只要是函数式接口就可以使用Lambda表达式表示
         */
//        Function function = new Function<String,String>() {
//            @Override
//            public String  apply(String o) {
//
//                return o;
//            }
//        };
        
        //lambda表达式简化
       Function<String,String> function = (str)->{
            return str;
        };
        System.out.println(function.apply("123"));
    }
}

Predicate (断定型接口)

在这里插入图片描述

/**
 * 断定型接口，有一个输入参数，返回值只能是布尔型
 */
public class PredicateDemo {
    public static void main(String[] args) {
        //判断字符串是否为空
//        Predicate<String> pr = new Predicate<String>() {
//            @Override
//            public boolean test(String str) {
//                return str.isEmpty();
//            }
//        };

        //lambda表达式简化
        Predicate<String> pr = (str)->{
            return str.isEmpty();
        };
        System.out.println(pr.test(""));
    }
}

Consumer (消费型接口)

在这里插入图片描述

/**
 * 消费型接口：只有输入，没有返回值
 */
public class ConsumerDemo {
    public static void main(String[] args) {
//        Consumer<String> consumer = new Consumer<String>() {
//            @Override
//            public void accept(String o) {
//                System.out.println(o);
//            }
//        };

        //lambda表达式
        Consumer<String> consumer = (str)->{
            System.out.println(str);
        };

        consumer.accept("15645");
    }
}

Supplier （供给型接口）

在这里插入图片描述

/**
 * 供给型函数：没有参数只有返回值
 */
public class SupplierDemo {
    public static void main(String[] args) {
//        Supplier<Integer> supplier = new Supplier<Integer>() {
//            @Override
//            public Integer get() {
//                System.out.println("get()");
//                return 1024;
//            }
//        };

        //lambda表达式
        Supplier<Integer> supplier = ()->{
            return 1024;
        };
        System.out.println(supplier.get());
    }
}

13、Stream流式计算

什么是Stream流式计算
大数据 = 存储（集合、mysql） + 计算（交给流操作）

/**
 *  题目要求：只能用一行代码
 *  1.ID必须为偶数
 *  2.年龄必须大于18岁
 *  3.用户名转化为大写
 *  4.用户名字母倒着排序
 *  5.只输出一个用户
 */
public class StreamDemo {
    public static void main(String[] args) {
        User user1 = new User(1, "zhangsan", 18);
        User user2 = new User(2, "lisi", 19);
        User user3 = new User(3, "wangwu", 20);
        User user4 = new User(4, "zhaoliu", 21);

        //转化为list集合
        List<User> users = Arrays.asList(user1, user2, user3, user4);
        //计算交给Stream流
        users.stream()
                .filter((u)->{return u.getId()%2 == 0;})
                .filter((u)->{return u.getAge()>18;})
                .map((u)->{return u.getName().toUpperCase();})
                .sorted((t1,t2)->{return t1.compareTo(t2);})
                .limit(1)
                .forEach(System.out::println);
    }
}

14、ForkJoin(分支合并)

什么是ForkJoin
ForkJoin在JDK 1.7，并执行并发任务！提高效率，大数据量
大数据：Map Reduce() 大任务拆分成小任务

特点：工作窃取
这里面维护的都是双端队列
A线程执行慢，B线程执行快，B线程执行完会将A未执行完的任务执行

ForkJoin 操作

//求和计算的任务
    // 如何使用ForkJoin
    //1.ForkJoinPool   通过他来执行
    //2.计算任务forkjoinPool.execute(ForkJoinTask <?> task)
    //3.计算类必须继承 RecursiveTask
public class ForkJoinDemo extends RecursiveTask<Long>{
    private Long start;   // 1
    private Long end;    // 1000000000000

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

    public ForkJoinDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }

   //计算方法
    @Override
    protected Long compute() {
        if ((end - start) < tmp){
            Long sum = 0L;
            for (Long i = start; i <= end ; i++) {
                sum += i;
            }
            return sum;
        }else {
            //分之合并计算
            Long middle =  ( start + end ) / 2;  //中间值
            ForkJoinDemo forkJoinDemo1 = new ForkJoinDemo(start, middle);
            forkJoinDemo1.fork();  //拆分任务，把任务压入线程队列
            ForkJoinDemo forkJoinDemo2 = new ForkJoinDemo(middle, end);
            forkJoinDemo2.fork();
            return forkJoinDemo1.join()+forkJoinDemo2.join();
        }
    }
}

public class ForkJoinDemoTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //test1();   //时间 7138
        //test2();  //6120
        test3();   //170
    }

    //普通程序员
    public static void test1(){
        long start = System.currentTimeMillis();
        Long sum = 0L;
        for (Long i = 1L; i <= 10_0000_0000 ; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum = "+sum+"\n时间"+(end-start));
    }

    //会使用ForkJoin的
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinDemo forkJoinDemo = new ForkJoinDemo(0L,10_0000_0000L);
        //forkJoinPool.execute(forkJoinDemo);
        forkJoinPool.submit(forkJoinDemo);   //提交任务
        Long sum = forkJoinDemo.get();
        long end = System.currentTimeMillis();
        System.out.println("sum = "+sum+"\n时间"+(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+"\n时间"+(end-start));
    }
}

15、异步回调

Future :设计的初衷：对将来的某个事件建模

/**
 * 异步调用： Ajax
 * 异步执行
 * 成功回到
 * 失败回调
 */
public class FutureDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //没有返回值的异步回调
        //发起一个请求
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"runAsync");
        });
        System.out.println("11111");
        //获取执行结果,阻塞
        completableFuture.get();

        //有返回结果的异步回调 supplyAsync
        CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"supplyAsync");
            int i= 1/0;
            return 1024;
        });

        System.out.println(completableFuture1.whenComplete((t1, t2) -> {   //t1 正常的返回结果
            System.out.println(t1 + "=====>" + t2);
        }).exceptionally((t) -> {
            System.out.println(t.getMessage());
            return 404;
        }).get());
    }
}

16、JMM

请你谈谈对Volatile的理解

Volatile是Java中提供的轻量级的同步机制

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

JMM是什么？

JMM：java内存模型，不存在，是一种约定，

关于JMM的一些同步约定

线程解锁前，必须把共享变量立刻刷新到主存。
线程加锁前，必须读取主存中的最新值到自己的工作内存中。
保证加锁和解锁必须是同一把锁。

线程：工作内存、主内存

八种操作：

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

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

在这里插入图片描述

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

17、Volatile

保证可见性

public class VolatileDemo {
    
    //不加 Volatile 程序进入死循环
    //加 Volatile ，程序可以保证可见性
    private volatile static int num = 0;
    public static void main(String[] args) {   //主线程

        new Thread(()->{  //线程 1  对主内存的变化不知道的
            while (num == 0){

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

    }
}

不保证原子性

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

//不保证原子性
public class VolatileDemo2 {
    private volatile static int num = 0;
    public static void add(){
        num++;
    }
    public static void main(String[] args) {
        for (int i = 1; i <= 20 ; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000 ; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){  //main  gc
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"--->"+num);
    }
}

如果不加 Lock 或者 Synchronoized 如何保证原子性

使用原子类，解决问题

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

这些类的底层直接和操作系统有关！Unsafe类是一个很特殊的存在

指令重排

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

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

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

int x = 1;  //1
int y = 2;  //2
x = x+5;    //3
y = x*x;    //4
//我们所期望的执行是 -> 1 2 3 4    2 1 3 4  1 3 2
//可不可能是 4123

可能造成的影响：a b x y 默认都是 0

线程A	线程B
x = a	y = b
b = 1	a = 2
正常结果： x = 0,y =0

线程A	线程B
b = 1	a = 2
x = a	y = b
指令重排导致异常结果： x = 2,y =1

Volatile 可以避免指令重排

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

保证特定的操作顺序
可以保证某些变量内存的可见性（利用这些特性vlatile就可以实现）

18、彻底玩转单例模式

饿汉式

//饿汉式 单例模式
public class HungryDemo {

    //可能会浪费空间
    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 HungryDemo(){
    }

    private static HungryDemo hungryDemo = new HungryDemo();

    public static HungryDemo getHungryDemo(){
        return hungryDemo;
    }

}

懒汉式

//懒汉式 单例模式
public class LazyDemo {
    private LazyDemo(){
      System.out.println(Thread.currentThread().getName()+"ok");
    }

    private volatile static LazyDemo lazyDemo;

    public static LazyDemo getLazyDemo(){

        //加锁,双重检测锁模式 简称 DCL 懒汉式
        if (lazyDemo == null){
            synchronized (LazyDemo.class){
                if (lazyDemo == null){
                    lazyDemo = new LazyDemo();   //不是一个原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法初始化对象
                     * 3.把这个对象指向这个空间
                     * 会出现指令重排   加上volatile
                     */
                }
            }
        }
        return lazyDemo;
    }

    //多线程并发
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
              LazyDemo.getLazyDemo();
            },String.valueOf(i)).start();

        }
    }
}

静态内部类

//静态内部类实现单例模式
public class Holder {

    //构造私有化
    private Holder(){}

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

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

}

单例不安全，存在反射

//懒汉式 单例模式
public class LazyDemo {
    private LazyDemo(){
        synchronized (LazyDemo.class){
            throw new RuntimeException("不要试图使用反射创建对象");
        }
        //System.out.println(Thread.currentThread().getName()+"ok");
    }

    private volatile static LazyDemo lazyDemo;

    public static LazyDemo getLazyDemo(){

        //加锁,双重检测锁模式 简称 DCL 懒汉式
        if (lazyDemo == null){
            synchronized (LazyDemo.class){
                if (lazyDemo == null){
                    lazyDemo = new LazyDemo();   //不是一个原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法初始化对象
                     * 3.把这个对象指向这个空间
                     * 会出现指令重排   加上volatile
                     */
                }
            }
        }
        return lazyDemo;
    }

    //多线程并发
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//        for (int i = 1; i <= 10; i++) {
//            new Thread(()->{
//                LazyDemo.getLazyDemo();
//            },String.valueOf(i)).start();
//
//        }

        //反射
        LazyDemo lazyDemo = LazyDemo.getLazyDemo();
        Constructor<LazyDemo> constructor = LazyDemo.class.getConstructor(null);
        constructor.setAccessible(true);
        LazyDemo lazyDemo1 = constructor.newInstance();
        System.out.println(lazyDemo);
        System.out.println(lazyDemo1);
    }

}

枚举，

//使用枚举
public enum  EnumDemo {
    INSTANCE;

    public EnumDemo getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumDemo enumDemo1 = EnumDemo.INSTANCE;
        Constructor<EnumDemo> declaredConstructor = EnumDemo.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumDemo enumDemo = declaredConstructor.newInstance();
        System.out.println(enumDemo);
        System.out.println(enumDemo1);
    }
}

在这里插入图片描述
反射不能破坏枚举的单例模式

19、深入理解CAS

什么是CAS？

public class CASDemo {

    //CAS:比较并交换
    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 类

在这里插入图片描述

CAS ：比较当前内存中的值和主内存中的值，如果这个值是期望的值，那就进行更新，否则，就一直循环进行（自旋锁）

缺点：

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

ABA 问题（狸猫换太子）

 AtomicInteger  atomicInteger = new AtomicInteger(2020);
        //对于sql操作：乐观锁
        //期望值、更新值
        //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(2021, 2020));
        System.out.println(atomicInteger.get());

        //=============期望的线程==========

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

20、原子引用

解决ABA问题，引入原子引用，对应的思想—> 乐观锁

带版本号的原子操作！

Integer 使用了对象缓存机制，默认范围是 -128~ 127 ，推荐使用静态工厂的方法 ValueOf（）获取对象实例，而不是 new，因为valueOf（）使用缓存，而 new 一定会创建新的对象分配新的内存空间。

public class CASDemo {

    //CAS:比较并交换
    public static void main(String[] args) {

//        AtomicInteger  atomicInteger = new AtomicInteger(2020);
//        AtomicReference<Object> atomicReference = new AtomicReference<>();
        //如果泛型是一个包装类，注意引用问题
        AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(12,1);

        new Thread(()->{
            int stamp = stampedReference.getStamp();   //获取最新的版本号
            System.out.println("A1====>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(stampedReference.compareAndSet(12, 123, stamp, stamp + 1));
            System.out.println("A2====>"+stampedReference.getStamp());

            System.out.println(stampedReference.compareAndSet(123, 12, stampedReference.getStamp(), stampedReference.getStamp() + 1));
            System.out.println("A3====>"+stampedReference.getStamp());

            },"A").start();

        new Thread(()->{
            int stamp = stampedReference.getStamp();   //获取最新的版本号
            System.out.println("B1====>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(6);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(stampedReference.compareAndSet(12, 113, stamp, stamp + 1));
            System.out.println("B2====>"+stampedReference.getStamp());

        },"B2").start();

    }
}

21、各种锁的理解

1、公平锁、非公平锁

公平锁：非常公平，不能插队，必须先来后到
非公平锁：非常不公平，可以插队，（默认非公平锁）

Lock lock = new ReentrantLock(true);

2、可重入锁

可重入锁（递归锁）

拿到了外面的锁就可以拿到里面的锁（自动获得的）

synchronoized

// Synchronoized
public class ReentrantLockDemo {
    public static void main(String[] args) {
        Ph phone = new Ph();
        new Thread(()->{
            phone.sms();
        },"A").start();

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

    }
}

class Ph{

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

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

lock

public class ReentrantLockDemo2 {
    public static void main(String[] args) {
        Ph2 phone = new Ph2();
        new Thread(()->{
            phone.sms();
        },"A").start();

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

    }
}

class Ph2{
    Lock lock = new ReentrantLock();

    public void sms(){
        lock.lock();   //细节问题， lock.lock()  lock.unlock()
        lock.lock();
        //lock锁必须匹配，不然就会死锁
        try {
            System.out.println(Thread.currentThread().getName()+"SMS");
            call();   //这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            lock.unlock();
        }

    }
    public void call(){
        lock.lock();   //细节问题， lock.lock()  lock.unlock()
        try {
            System.out.println(Thread.currentThread().getName()+"CALL");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

3、自旋锁

spinlock
在这里插入图片描述

自定义锁测试

//自旋锁
public class SpinLockDemo {
    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);
    }

    public static void main(String[] args) throws InterruptedException {

        //底层使用的是 CAS
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(()->{
            spinLockDemo.myLock();  //加锁
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLockDemo.myUnLock(); //解锁
            }
        },"A").start();


        TimeUnit.SECONDS.sleep(1);


        new Thread(()->{
            spinLockDemo.myLock();  //加锁
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLockDemo.myUnLock(); //解锁
            }

        },"B").start();
        
    }

}

4、死锁

死锁是什么？

怎么排除死锁？

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

class MyThread1 implements Runnable{
    private String lockA;
    private String lockB;

    public MyThread1(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(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lock"+lockB+"==>get"+lockA);
            }
        }
    }
}