juc高并发进阶

所有代码在 juc-study

1、什么是JUC

JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。

查看jdk帮助文档

2、线程和进程

2.1、进程线程：

进程：

一个进程至少包含一个线程
java默认有2个线程：main、GC

线程：

对于Java而言：Thread、Runable、Callable进行开启线程的。

提问？JAVA真的可以开启线程吗？开不了的！

Java是没有权限去开启线程、操作硬件的，这是一个native的一个本地方法，它调用的底层的C++代码。

start0()方法native本地方法

//这是一个C++底层，Java是没有权限操作底层硬件的
private native void start0();

2.2、并发，并行

并发编程：并发、并行

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

CPU 只有一核，模拟出来多条线程，天下武功，唯快不破。那么我们就可以使用CPU快速交替，来模拟多线程。
并发编程的本质：充分利用CPU的资源

并行： 多个人一起行走

CPU多核，多个线程可以同时执行。我们可以使用线程池！

package com.badwei.demo01;

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

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

2.3、线程的状态

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

2.4、wait/sleep区别

1、来自不同的类，

wait Object类

sleep Thread类

一般情况企业中使用休眠是：

TimeUnit.DAYS.sleep(1); //休眠1天
TimeUnit.SECONDS.sleep(1); //休眠1s

2、关于锁的释放

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

3、使用的范围不同

wait必须在同步代码块/同步方法中

sleep可以在任何地方睡

4、是否需要捕获异常

wait是不需要捕获异常；

sleep必须要捕获异常；

3、Lock

3.1、传统的 synchronized

多线程不要这么做：

public class SaleTicketDemo01 {
    public static void main(String[] args) {
        new Thread(new MyThread()).start();
    }
}

//直接实现Runnable耦合性非常强，不建议使用
class MyThread implements Runnable{
    
    @Override
    public void run() {

    }
}

要这么做：做一个资源类

package com.badwei.demo01;

/**
 * 真正的线程开发，公司中的研发
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1、属性
 * 2、方法
 */

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

        //多个线程同时操作同一个资源类
        Ticket ticket = new Ticket();

        //Runnable 是一个@FunctionalInterface函数式接口，可以new
        //lambda表达式(参数)->{代码}
        new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        },"C").start();


    }
}

// 资源类 OOP
class Ticket {

    private int number = 50;
    public void sale(){

        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了" + number-- + "票，"+"剩余" + number + "票");
        }
    }

}

现在存在多线程的安全问题

使用传统的synchronized解决【在资源类方法存在线程安全的方法上加入synchronized】

public synchronized void sale(){

线程安全。

3.2、Lock

公平锁： 十分公平，必须先来后到~；

非公平锁： 十分不公平，可以插队；(默认为非公平锁)

使用lock解决

package com.badwei.demo01;

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

/**
 * 真正的线程开发，公司中的研发
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1、属性
 * 2、方法
 */

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

        Ticket2 ticket = new Ticket2();


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



    }
}

// Lock三部曲
/*
1、new ReentrantLock()
2、lock.lock()加锁
3、finally -> lock.unlock()解锁
 */
class Ticket2 {

    private int number = 50;
    Lock lock = new ReentrantLock();
    public  void sale(){

        lock.lock();// 加锁

        try {
            //业务代码
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"卖出了" + number-- + "票，"+"剩余" + number + "票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();// 解锁
        }
    }

}

测试：线程安全

3.3、syschronized和Lock的区别

1、Synchronized 内置的Java关键字，Lock是一个Java接口

2、Synchronized 无法判断获取锁的状态，Lock可以判断

3、Synchronized 会自动释放锁，lock必须要手动加锁和手动释放锁！可能会遇到死锁

4、Synchronized 线程1(获得锁->阻塞)、线程2(等待)；lock就不一定会一直等待下去，lock会有一个trylock()去尝试获取锁，不会造成长久的等待。

5、Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；

6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码，更灵活；

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

4、生产者和消费者问题

4.1、Synchronized版 wait notify

package com.badwei.pc;

/**
 * 线程之间的通信：生产者消费者问题，等待唤醒，通知唤醒
 * 线程交替执行
 *
 */


public class A {

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

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

    }
}

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

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

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

}

4.2、if存在问题（虚假唤醒）

问题，如果有四个线程，会出现虚假唤醒

解决方式，if 改为while即可，防止虚假唤醒

结论：就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。

这也就是为什么用while而不用if的原因了，因为线程被唤醒后，执行开始的地方是wait之后

package com.badwei.pc;

/**
 * 线程之间的通信：生产者消费者问题，等待唤醒，通知唤醒
 * 线程交替执行
 *
 */


public class A {

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

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

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

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

    }
}

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

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

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

}

4.3、Lock版

package com.badwei.pc;

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

/**
 * 线程之间的通信：生产者消费者问题，等待唤醒，通知唤醒
 * 线程交替执行
 *
 */


public class B {

    public static void main(String[] args) {
        Data2 data = new Data2();

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

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

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

    }
}

//判断等待，业务，通知
//资源类
class Data2{
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    //condition.await();//等待
    //condition.signalAll();//唤醒全部

    public  void increment() throws InterruptedException {
        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();
        }



    }

    public  void decrement() throws InterruptedException {
        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();
        }

    }

}

4.4、Condition的优势

精准的通知和唤醒的线程！

按照顺序执行三个线程

package com.badwei.pc;

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

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

        Data3 data = new Data3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();

    }
}

class Data3{ // 资源类 Lock

    private int number = 1;
    private Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3= lock.newCondition();

    public void printA(){
        lock.lock();
        try {
            while(number!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"aaaaaaaaaaa");
            number = 2;
            //唤醒指定的人
            condition2.signal();//唤醒2

        } 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()+"bbbbbbbbbbb");
            number = 3;
            condition3.signal();//唤醒3
        } 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()+"cccccccccc");
            number = 1;
            condition1.signal();//唤醒1

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

}

5、8锁问题

如何判断锁的是谁！锁到底锁的是谁？

锁会锁住：对象、Class

深刻理解我们的锁

问题1

两个同步方法，先执行发短信还是打电话

package com.badwei.lock8;

import java.util.concurrent.TimeUnit;

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

        new Thread(phone::sendMs).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(phone::call).start();
    }
}
class Phone {
    public synchronized void sendMs() {
        System.out.println("发短信");
    }
    public synchronized void call() {
        System.out.println("打电话");
    }
}

输出结果为

发短信

打电话

为什么？如果你认为是顺序在前？这个答案是错误的！

问题2：

我们再来看：我们让发短信延迟4s

package com.badwei.lock8;

import java.util.concurrent.TimeUnit;

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

        new Thread(phone::sendMs).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(phone::call).start();
    }
}
class Phone {
    public synchronized void sendMs() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call() {
        System.out.println("打电话");
    }
}

现在结果是什么呢？

结果：还是先发短信，然后再打电话！

why？

原因：并不是顺序执行，而是synchronized 锁住的对象是方法的调用！对于两个方法用的是同一个锁，谁先拿到谁先执行，另外一个等待

确实是发短信先执行，重要的是发短信获得了锁，而发短信和打电话用的是同一把锁，所以发短信执行结束后，才执行打电话

问题3

加一个普通方法

package com.badwei.lock8;

import java.util.concurrent.TimeUnit;

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

        new Thread(phone::sendMs).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(phone::hello).start();
    }
}
class Phone {
    public synchronized void sendMs() {
        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");
    }
}

输出结果为

hello

发短信

原因：hello是一个普通方法，不受synchronized锁的影响，不用等待锁的释放

问题4

如果我们使用的是两个对象，一个调用发短信，一个调用打电话，那么整个顺序是怎么样的呢？

package com.badwei.lock8;

import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        // 两个对象 两个同步方法
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(phone1::sendMs).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(phone2::call).start();
    }
}
class Phone {
    public synchronized void sendMs() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call() {
        System.out.println("打电话");
    }
}

输出结果

打电话

发短信

原因：两个对象两把锁，不会出现等待的情况，发短信睡了4s,所以先执行打电话

问题5、6

如果我们把synchronized的方法加上static变成静态方法！那么顺序又是怎么样的呢？

（1）我们先来使用一个对象调用两个方法！

（2）如果我们使用两个对象调用两个方法！

【本质：一个锁】

【这里其实没有一个对象，两个对象之分了，因为类只有一个，静态方法随着类的创建而创建，也是全局唯一，所以无论几个对象，锁都是class，锁唯一】

原因是什么呢？为什么加了static就始终前面一个对象先执行呢！为什么后面会等待呢？

原因是：对于static静态方法来说，对于整个类Class来说只有一份，对于不同的对象使用的是同一份方法，相当于这个方法是属于这个类的，如果静态static方法使用synchronized锁定，那么这个synchronized锁会锁住整个对象！不管多少个对象，对于静态的锁都只有一把锁，谁先拿到这个锁就先执行，其他的进程都需要等待！

答案是：先发短信，后打电话

package com.badwei.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 增加static
 */
public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        //锁的是Phone的Class，锁的是类

        new Thread(Phone3::sendMs,"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(Phone3::call,"B").start();
    }
}
class Phone3 {
    // 静态方法，随着类的创建而创建，锁的是类class全局唯一
    public static synchronized void sendMs() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call() {
        System.out.println("打电话");
    }
}

问题7、8

如果我们使用一个静态同步方法、一个同步方法、一个对象调用顺序是什么？

如果我们使用一个静态同步方法、一个同步方法、两个对象调用顺序是什么？

答案是：先打电话，后发短信

【本质：两个锁】

无论new几个对象，只要调用的是静态方法，就锁的是Class本身，如果调用的普通方法，则锁的是调用者(新的new对象)。

package com.badwei.lock8;

import java.util.concurrent.TimeUnit;

public class Test4 {
    public static void main(String[] args) throws InterruptedException {
        //锁的是Phone的Class，锁的是类

        Phone4 phone4 = new Phone4();

        new Thread(Phone4::sendMs,"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(phone4::call,"B").start();

    }
}
class Phone4 {
    // 静态方法，随着类的创建而创建，锁的是类class全局唯一
    public static synchronized void sendMs() {//锁的是Class
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call() {//锁的是调用者，对象
        System.out.println("打电话");
    }
}

6、集合类不安全

List 不安全

package com.badwei.unsafe;

import java.util.*;

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();

        }
    }
}

会导致 java.util.ConcurrentModificationException 并发修改异常！

ArrayList 在并发情况下是不安全的

解决方案：

package com.badwei.unsafe;

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

public class ListTest {
    public static void main(String[] args) {
        /**
         * 解决方案：
         * 1、List<String> list = new Vector<>();
         * 2、List<String> list = Collections.synchronizedList(new ArrayList<>());
         * 3、List<String> list = new CopyOnWriteArrayList<>();
         */
        //写入时复制 COW，计算机程设计领域的一种优化策略
        //多个线程在调用的时候，list，读取的时候，固定的，写入（覆盖）
        //在写入的时候避免覆盖，造成数据问题
        //CopyOnWriteArrayList 的优点

        //读写分离，java层面，数据库层面
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {

            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();

        }
    }
}

CopyOnWriteArrayList：写入时复制！ COW 计算机程序设计领域的一种优化策略

核心思想是，如果有多个调用者（Callers）同时要求相同的资源（如内存或者是磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者视图修改资源内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的调用者都是透明的（transparently）。此做法主要的优点是如果调用者没有修改资源，就不会有副本（private copy）被创建，因此多个调用者只是读取操作时可以共享同一份资源。

读的时候不需要加锁，如果读的时候有多个线程正在向CopyOnWriteArrayList添加数据，读还是会读到旧的数据，因为写的时候不会锁住旧的CopyOnWriteArrayList。

多个线程调用的时候，list，读取的时候，固定的，写入（存在覆盖操作）；在写入的时候避免覆盖，造成数据错乱的问题；

CopyOnWriteArrayList比Vector厉害在哪里？
Vector底层是使用synchronized关键字来实现的：效率特别低下。

CopyOnWriteArrayList使用的是Lock锁，效率会更加高效！

set 不安全

Set和List同理可得: 多线程情况下，普通的Set集合是线程不安全的；

解决方案还是两种：

使用Collections工具类的synchronized包装的Set类
使用CopyOnWriteArraySet 写入复制的JUC解决方案

package com.badwei.unsafe;

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

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

//        Set<String> set = new HashSet<>(); //不安全
//        Set<String> set = Collections.synchronizedSet(new HashSet<>()); // 解决1
        Set<String> set = new CopyOnWriteArraySet<>(); //解决2
        for (int i = 0; i < 30; i++) {

            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();

        }
    }
}

Map不安全

//map 是这样用的吗？  不是，工作中不使用这个
//默认等价什么？ new HashMap<>(16,0.75);
Map<String, String> map = new HashMap<>();
//加载因子、初始化容量

默认加载因子是0.75,默认的初始容量是16

同样的HashMap基础类也存在并发修改异常！

public class MapTest {
    public static void main(String[] args) {
        //map 是这样用的吗？  不是，工作中不使用这个
        //默认等价什么？ new HashMap<>(16,0.75);
        /**
         * 解决方案
         * 1. Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
         *  Map<String, String> map = new ConcurrentHashMap<>();
         */
        Map<String, String> map = new ConcurrentHashMap<>();
        //加载因子、初始化容量
        for (int i = 1; i < 100; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

TODO:研究ConcurrentHashMap底层原理：

7. Callable

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

细节：

1.有缓存

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

package com.badwei.callable;

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

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        new Thread().start();

        MyThread thread = new MyThread();
        FutureTask<Integer> futureTask = new FutureTask<>(thread); // 适配类
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();// 结果会被缓存，提高效率


        Integer integer = futureTask.get();
        // 这个get方法可能会被阻塞，如果在call方法中是一个耗时的方法，所以一般情况我们会把这个放在最后，或者使用异步通信
        System.out.println(integer);

    }
}

class MyThread implements Callable<Integer> {

    @Override
    public Integer call() {
        System.out.println("Call()...");
        return 1024;
    }
}

8、常用辅助类

8.1、CountDownLatch

【减法计数器】

package com.badwei.add;

import java.util.concurrent.CountDownLatch;

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

        //总数设置为6，必须要执行任务的时候，再使用
        CountDownLatch countDownLatch = new CountDownLatch(6);
        
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "Go Out");
                countDownLatch.countDown(); //数量-1
            }).start();
        }
        
        countDownLatch.await(); //等待计数器归零，然后再往下执行
        System.out.println("Close Door");

    }
}

原理：

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

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

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

await 等待计数器归零，就唤醒，再继续向下运行

8.2、CyclickBarrier

【加法计数器】

package com.badwei.add;


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

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         * 集齐7颗龙珠召唤神龙
         */
        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();
                }
            }).start();

        }
    }
}

8.3、Semaphore

【信号量】

官方文档，看的头疼，也看不懂。。。

抢车位

package com.badwei.add;

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

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 线程数量：停车位！限流！
        // 一共3个车位
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i <= 6; i++) {
            new Thread(()->{
                // acquire() 得到
                // release() 释放
                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();
        }
    }
}

执行结果:

0抢到车位
2抢到车位
1抢到车位
1离开车位
2离开车位
0离开车位
3抢到车位
6抢到车位
5抢到车位
6离开车位
3离开车位
5离开车位
4抢到车位
4离开车位

原理：

semaphore.acquire()获得资源，如果资源已经使用完了，就等待资源释放后再进行使用！

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

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

9、读写锁

ReadWriteLock
写锁，为了防止其他读写
读锁，可以多人读，但是不能写
独占锁：写锁，一次只能被一个线程占用
共享锁：读锁，多个线程可以同时占用

测试：

没有锁的时候，会出现，多个同时写的问题。

需要加锁。

package com.badwei.rw;

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

/**
 * ReadWriteLock
 * 写锁，为了防止其他读写
 * 读锁，可以多人读，但是不能写
 * 独占锁：写锁，一次只能被一个线程占用
 * 共享锁：读锁，多个线程可以同时占用
 */
public class ReadWriteLockDemo {

    public static void main(String[] args) {
//        MyCache myCache = new MyCache();
        MyCacheLock myCache = new MyCacheLock();

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

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

}

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

    //存，写  只希望同时只有一个线程在读
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入" + key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "写入OK");
        } finally {
            readWriteLock.writeLock().unlock();
        }

    }
    //取，读  所有人都可以读
    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取" + key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取OK" );
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

// 没有锁的时候
class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();

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

10、阻塞队列

10.1、BlockQueue

是Collection的一个子类

什么情况下我们会使用阻塞队列

多线程并发处理、线程池

BlockQueue四组API

方式	1.抛出异常	2.不会抛出异常，有返回值	3.阻塞，等待	4.超时等待,不抛异常,有返回值
添加	add	offer	put	offer(timenum.timeUnit)
移出	remove	poll	take	poll(timenum,timeUnit)
判断队首元素	element	peek	-	-

测试

package com.badwei.blockqueue;

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

public class MyTest {
    public static void main(String[] args) throws InterruptedException {
//        test1();
//        test2();
//        test3();
        test4();
    }

    /**
     * 抛出异常
     */
    public static void test1(){
        // 队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));

        // System.out.println(blockingQueue.element()); // 队首元素
        // 在队列元素为空的情况下，element() 方法会抛出NoSuchElementException异常，peek() 方法只会返回 null。

        // IllegalStateException: Queue full 抛出异常
        // System.out.println(blockingQueue.add("d"));
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());

        // NoSuchElementException 抛出异常
        // System.out.println(blockingQueue.remove());



    }

    /**
     * 不抛出异常，有返回值
     */
    public static void test2(){
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));

        // 输出false 不抛出异常
        // System.out.println(blockingQueue.offer("d"));

        // System.out.println(blockingQueue.peek());    // 队首元素
        // 在队列元素为空的情况下，element() 方法会抛出NoSuchElementException异常，peek() 方法只会返回 null。

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

        // 输出null 不抛出异常
        // System.out.println(blockingQueue.poll());


    }

    /**
     * 等待，阻塞（一直阻塞）
     */
    public static void test3() throws InterruptedException {
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
//        blockingQueue.put("d"); // 队列没有位置了，一直阻塞

        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
//        System.out.println(blockingQueue.take());// 队列没有元素，一直阻塞
    }

    /**
     * 超时等待
     */
    public static void test4() throws InterruptedException {

        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
        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)); //超时退出，有返回值false

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll(2,TimeUnit.SECONDS)); //超时退出，有返回值null


    }
}

10.2、Synchronized 同步队列

同步队列

没有容量，也可以视为容量为1的队列；

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

put方法和 take方法；

Synchronized 和其他的BlockingQueue 不一样它不存储元素；

put了一个元素，就必须从里面先take出来，否则不能再put进去值！

并且SynchronousQueue 的take是使用了lock锁保证线程安全的。

package com.badwei.blockqueue;

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

public class SynchronousQueueDemo {
    public static void main(String[] args) {
//        BlockingDeque<String> blockingDeque = new SynchronousQueue<>();
        SynchronousQueue<String> blockingDeque = new SynchronousQueue<>();

        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName() + "put 1");
                blockingDeque.put("1");
                System.out.println(Thread.currentThread().getName() + "put 2");
                blockingDeque.put("2");
                System.out.println(Thread.currentThread().getName() + "put 3");
                blockingDeque.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"T1").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"take "+ blockingDeque.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"take "+ blockingDeque.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"take "+ blockingDeque.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"T2").start();

       
    }
}

输出

T1put 1
T2take 1
T1put 2
T2take 2
T1put 3
T2take 3

11、线程池（重点）

线程池：三大方式、七大参数、四种拒绝策略

池化技术

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

线程池、JDBC的连接池、内存池、对象池等等。。。。

资源的创建、销毁十分消耗资源

**池化技术：**事先准备好一些资源，如果有人要用，就来我这里拿，用完之后还给我，以此来提高效率。

11.1、线程池的好处：

1、降低资源的消耗；

2、提高响应的速度；

3、方便管理；

线程复用、可以控制最大并发数、管理线程；

11.2、线程池：三大方法

ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的

测试

package com.badwei.pool;

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

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

        try {
            for (int i = 0; i < 100; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完后，程序结束，关闭线程池
            threadPool.shutdown();
        }

    }

}

11.3、七大参数

查看三大方法的源码

// Executors.newSingleThreadExecutor();
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
// Executors.newFixedThreadPool(5);
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
// Executors.newCachedThreadPool();
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

发现本质：三个方法底层都是调用的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;
}

所以阿里巴巴的Java操作手册中明确说明：对于Integer.MAX_VALUE初始值较大，所以一般情况我们要使用底层的ThreadPoolExecutor来创建线程池。

11.4、拒绝策略

1、new ThreadPoolExecutor.AbortPolicy()： //该拒绝策略为：银行满了，还有人进来，不处理这个人的，并抛出异常

超出最大承载，就会抛出异常：队列容量大小+maxPoolSize

2、new ThreadPoolExecutor.CallerRunsPolicy()： //该拒绝策略为：哪来的去哪里 main线程进行处理

3、new ThreadPoolExecutor.DiscardPolicy(): //该拒绝策略为：队列满了,丢掉异常，不会抛出异常。

4、new ThreadPoolExecutor.DiscardOldestPolicy()： //该拒绝策略为：队列满了，尝试去和最早的进程竞争，不会抛出异常

11.5、自定义线程池ThreadPoolExecutor

package com.badwei.pool;

import java.util.concurrent.*;

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

        //最大线程应该如何定义
        //1、CPU 密集型，几核的CPU就是几，可以保证CPU的效率最高
        //2、IO 密集型  大于判断程序中十分耗IO的线程
        
        System.out.println(Runtime.getRuntime().availableProcessors()); //获取CPU的核数

        ExecutorService threadPool =  new ThreadPoolExecutor(
                2,  //核心线程池大小 ---前台开放窗口
                5, // 最大核心线程池大小  ----总窗口（不开放，除非阻塞队列满了---也就是候客区满了）
                3, //超时时间，没有人调用就会释放
                TimeUnit.SECONDS, // 超时单位
                new LinkedBlockingQueue<>(3), //阻塞队列  ----候客区
                Executors.defaultThreadFactory(), // 线程工厂：创建线程的，一般不用动
//                new ThreadPoolExecutor.AbortPolicy() //拒绝策略 ----银行满了，还有人进来，不处理这个人了，抛出异常
//                new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略----哪来的回哪去，由于我们是main线程调用的这个进程，所以直接抛回给main线程
//                new ThreadPoolExecutor.DiscardOldestPolicy() //拒绝策略----处理线程，不会抛出异常啊，程序正常进行，丢弃任务
                new ThreadPoolExecutor.DiscardOldestPolicy() //拒绝策略----队列满了，尝试和最早的竞争，也不会抛出异常，竞争成功就执行，不成功就丢弃任务
        );

        try {
            // <=2 两个线程
            // 3-5 两个线程 ---这里直接进入候客区
            // 6-8 6三个线程  7四个线程 8五个线程  ---候客区也满了，启用剩余窗口，开放新进程
            // >=9 查看4种拒绝策略：AbortPolicy 抛出异常RejectedExecutionException
            //                CallerRunsPolicy 不抛出异常，哪来的回来去，这里返回给main线程
            //                DiscardOldestPolicy 不抛出异常，程序正常执行，直接丢弃任务
            //                DiscardOldestPolicy 尝试和最早的竞争，也不会抛出异常，竞争成功就执行，不成功就丢弃任务
            for (int i = 0; i < 9; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完后，程序结束，关闭线程池
            threadPool.shutdown();
        }

    }
}

11.6、如何设置线程池的大小(调优)

1、CPU密集型：电脑的核数是几核就选择几；选择maximunPoolSize的大小

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

2、IO密集型：在程序中有15个大型任务，io十分占用资源；I/O密集型就是判断我们程序中十分耗I/O的线程数量，大约是最大I/O数的一倍到两倍之间。

12、四大函数式接口*

12.1、什么是函数式接口

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

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

简化编程模型，在新版本的框架底层中大量应用！

典型的Runnable接口，就是一个函数式接口，只有一个方法，@FunctionalInterface修饰

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

典型的forEach是消费者函数式接口

打开任意forEach源码，

@Override
public void forEach(Consumer<? super E> action) {
    //实现方式
}

发现Consumer接口，点进去，就是Consumer消费者函数式接口

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

原生四大函数式接口

消费型接口Consumer<T> void accept(T t)
供给型接口Supplier<T> T get()
函数型接口Function<T,R> R apply(T t)
断定型接口Predicate<T> boolean test(T t)

Function函数型接口

Function<T,R> R apply(T t)

源码【函数型，有参数，有返回值】

原生的函数式接口

Function function = new Function<String,String>() {

    @Override
    public String apply(String s) {
        return s+s;
    }

};

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

修改为Lambda表达式后

//修改为Lambda表达式
// Function<String, String> function = (s) -> {return s+s;};
//简化Lambda
Function<String, String> function = s -> s+s;

Predicate断定型接口

Predicate<T> boolean test(T t)

源码【断定，返回布尔值】

package com.badwei.function;

import java.util.function.Predicate;

public class Demo02 {
    public static void main(String[] args) {
        //判断字符串是否为空
//        Predicate<String> predicate = new Predicate<String>(){
//
//            @Override
//            public boolean test(String s) {
//                return s.isEmpty();
//            }
//        };
        //函数式接口
//        Predicate<String> predicate = (s) -> {return s.isEmpty();};
//        Predicate<String> predicate = s -> s.isEmpty();
        //方法引用
        Predicate<String> predicate = String::isEmpty;

        System.out.println(predicate.test("ydd"));
    }
}

Consumer消费性接口

Consumer<T> void accept(T t)

源码【没有返回值，只消费数据】

测试：

package com.badwei.function;

import java.util.function.Consumer;

/**
 * Consumer,消费型接口，只有输入，没有返回值
 */
public class Demo03 {
    public static void main(String[] args) {
		// 消费一段数据(这里字节打印)，没有返回值
//        Consumer<String> consumer = new Consumer<String>(){
//
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        };

        //修改为Lambda
//        Consumer<String> consumer = (s) -> {
//            System.out.println(s);
//        };
        //修改为方法引用
        Consumer<String> consumer = System.out::println;

        consumer.accept("ydd");
    }
}

Supplier供给型接口

Supplier<T> T get()

源码【没有参数，只有返回值】

测试

package com.badwei.function;

import java.util.function.Supplier;

/**
 * Supplier, 供给型接口，没有参数，只返回数据
 */
public class Demo04 {
    public static void main(String[] args) {
        // 供给型接口，只供给数据，没有参数
//        Supplier<Integer> supplier = new Supplier<Integer>() {
//            @Override
//            public Integer get() {
//                return 1024;
//            }
//        };
        //Lambda
//        Supplier<Integer> supplier = ()->{return 1024;};
        Supplier<Integer> supplier = ()-> 1024;

        System.out.println(supplier.get());
    }
}

13、Stream流式计算

计算都应该交给流来操作

package com.badwei.stream;

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

/**
 * Description：
 * 题目要求： 用一行代码实现
 * 1. Id 必须是偶数
 * 2.年龄必须大于23
 * 3. 用户名转为大写
 * 4. 用户名倒序
 * 5. 只能输出一个用户
 *
 **/

public class StreamDemo {
    public static void main(String[] args) {
        User u1 = new User(1, "a", 23);
        User u2 = new User(2, "b", 23);
        User u3 = new User(3, "c", 23);
        User u4 = new User(6, "d", 24);
        User u5 = new User(4, "e", 25);

        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
        // lambda、链式编程、函数式接口、流式计算
        list.stream()
                .filter(user -> {return user.getId()%2 == 0;})
                .filter(user -> {return user.getAge() > 23;})
                .map(user -> {return user.getName().toUpperCase();})
                .sorted((user1, user2) -> {return user2.compareTo(user1);})
                .limit(1)
                .forEach(System.out::println);
    }
}

14、ForkJoin

ForkJoin 在JDK1.7，并行执行任务！提高效率~。在大数据量速率会更快！

大数据中：MapReduce 核心思想->把大任务拆分为小任务！

14.1、ForkJoin 特点：工作窃取！

实现原理是：双端队列！从上面和下面都可以去拿到任务进行执行！

14.2、如何使用ForkJoin?

1、通过ForkJoinPool来执行
2、计算任务 execute(ForkJoinTask<?> task)
3、计算类要去继承ForkJoinTask；

ForkJoin 的计算类

package com.badwei.forkjoin;

import java.util.concurrent.RecursiveTask;

/**
 * 求和计算
 * ForkJoinPool
 * 如何使用
 * 1. forkJoinPool通过它来执行
 * 2. 计算任务forkJoinPool.execute(ForkJoinPool task)
 * 3. 计算类要继承 ForkJoinTask
 */

public class ForkJoinDemo extends RecursiveTask<Long> {

    private long start;
    private long end;

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

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

    }

    // 计算方法
    @Override
    protected Long compute() {
        if ((end-start)<temp){
            long sum = 0L;
            for (long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }else{ //forkJoin 递归
            long middle = (start + end) / 2;

            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork(); //拆分任务，把线程压入队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
            task2.fork(); //拆分任务，把线程压入队列
            return task1.join() + task2.join();

        }
    }
}

ForkJon的测试类

package com.badwei.forkjoin;

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

/**
 * 测试类
 */
public class ForkJoinDemoTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        long startTime = System.currentTimeMillis();

        long start = 0L;
        long end = 10_0000_0000L;

        //方法一
//        Long sum = test1(start, end); //638
        //方法二
//        Long sum = test2(start,end); //352
        //方法三
        Long sum = test3(start,end); //242
        //方法四
//        Long sum = test4(start,end); //0

        long endTime = System.currentTimeMillis();
        System.out.println("sum=" +sum+ " 时间=" + (endTime-startTime));
    }

    public static long test1(Long start,Long end){
        long sum = 0L;
        for (long i = start; i <= end; i++) {
            sum += i;
        }
        return sum;
    }

    //ForkJoin
    public static Long test2(Long start,Long end) throws ExecutionException, InterruptedException {

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(start, end);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum = submit.get();

        return sum;
    }

    //Stream并行流
    public static long test3(Long start,Long end){

        long sum = LongStream.rangeClosed(start, end).parallel().reduce(0, Long::sum);

        return sum;

    }

    //方法四：等差数列公式
    // 等差数列{an}的通项公式为：an=a1+(n-1)d。前n项和公式为：Sn=n*a1+n(n-1)d/2或Sn=n(a1+an)/2

    public static long test4(Long start,Long end){
        long sum = (end-start)*(start+end)/2;
        return sum;
    }
}

Java8的Stream并行流底层使用了ForkJoin框架

先看看parallel()方法，进入相关的类AbstractPipeline中，如下：

abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
        extends PipelineHelper<E_OUT> implements BaseStream<E_OUT, S> {
private final AbstractPipeline sourceStage;

private boolean parallel;
@Override
@SuppressWarnings("unchecked")
public final S parallel() {
    sourceStage.parallel = true;
    return (S) this;
}
}

可以发现parallel()方法做的事很简单，就是标记个并行的标记，设置为true。

那么接下来看看reduce()方法：

abstract class ReferencePipeline<P_IN, P_OUT>
        extends AbstractPipeline<P_IN, P_OUT, Stream<P_OUT>>
        implements Stream<P_OUT>  {
    @Override
    public final Optional<P_OUT> reduce(BinaryOperator<P_OUT> accumulator) {
        return evaluate(ReduceOps.makeRef(accumulator));
    }
}

接着evaluate()方法跟下去，如下：

abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
        extends PipelineHelper<E_OUT> implements BaseStream<E_OUT, S> {
        
    final <R> R evaluate(TerminalOp<E_OUT, R> terminalOp) {
        assert getOutputShape() == terminalOp.inputShape();
        if (linkedOrConsumed)
            throw new IllegalStateException(MSG_STREAM_LINKED);
        linkedOrConsumed = true;

        return isParallel()
               ? terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))
               : terminalOp.evaluateSequential(this, sourceSpliterator(terminalOp.getOpFlags()));
    }

    @Override
    public final boolean isParallel() {
        return sourceStage.parallel;
    }
}

从以上的三元表达式中可以得出，调用isParallel()方法会得到之前通过parallel()方法设置的true值，然后就会执行terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))方法，所以接着跟进看看evaluateParallel()方法。

首先会进入TerminalOp接口类，如下：

interface TerminalOp<E_IN, R> {

      default <P_IN> R evaluateParallel(PipelineHelper<E_IN> helper,
                                      Spliterator<P_IN> spliterator) {
        if (Tripwire.ENABLED)
            Tripwire.trip(getClass(), "{0} triggering TerminalOp.evaluateParallel serial default");
        return evaluateSequential(helper, spliterator);
    }
}

会发现这是接口的默认方法，由于使用的是reduce方法，所以看看其相应的实现类对evaluateParallel()方法的实现，如下：

final class ReduceOps {
         @Override
         public <P_IN> R evaluateParallel(PipelineHelper<T> helper,
                                         Spliterator<P_IN> spliterator) {
            return new ReduceTask<>(this, helper, spliterator).invoke().get();
        }
}

这时候会发现，该方法中new了一个ReduceTask类，然后调用了它的invoke()方法，看看ReduceTask类相关信息，最后会发现它的继承链是这样的：

ReduceTask->AbstractTask->CountedCompleter->ForkJoinTask

可以发现最终跟到了ForkJoinTask类中，然后点击跟进invoke()方法，会发现调用的其实是ForkJoinTask()的invoke()方法，该方法是final修饰的，子类无法重写，如下：

   public final V invoke() {
        int s;
        if ((s = doInvoke() & DONE_MASK) != NORMAL)
            reportException(s);
        return getRawResult();
    }

总结

通过以上几步源码的跟踪，可以证明Java8的Stream并行流底层确实是使用了ForkJoin框架。

15、异步回调

Future 设计的初衷：对将来的某个事件结果进行建模！

其实就是前端 --> 发送ajax异步请求给后端

模型

但是我们平时都使用CompletableFuture

15.1、没有返回值的runAsync异步回调

package com.badwei.fature;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * 异步调用
 */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

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

        System.out.println("1111");

        completableFuture.get(); // 获取阻塞执行结果

    }
}

15.2、有返回值的异步回调supplyAsync

whenComplete: 有两个参数，一个是t 一个是u

T：是代表的 正常返回的结果；

U：是代表的 抛出异常的错误信息；

如果发生了异常，get可以获取到exceptionally返回的值；

package com.badwei.fature;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * 异步调用
 */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // 有返回值的 supplyAsync 异步回调
        //ajax,成功和失败的回调
        //返回的是错误信息
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
//            int i = 10/0;
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t=>" + t); // 正常的返回结果
            System.out.println("u=>" + u); // 错误信息
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233; // 可以获取到错误的返回结果
        }).get());

    }
}

16、JMM

请你谈谈你对Volatile的理解

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

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是JMM

JMM：JAVA内存模型，不存在的东西，是一个概念，也是一个约定！

Java Memory Model(Java内存模型)，围绕着在并发过程中如何处理可见性、原子性、有序性这三个特性而建立的模型。

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

1、线程解锁前，必须把共享变量立刻刷回主存；

2、线程加锁前，必须读取主存中的最新值到工作内存中；

3、加锁和解锁是同一把锁；

线程中分为 工作内存、主内存

8种操作：

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

JMM对这8种操作给了相应的规定：

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

问题：

遇到问题：程序不知道主存中的值已经被修改过了！；

测试问题代码

package com.badwei.volatiletest;

import java.util.concurrent.TimeUnit;

public class JMMDemo {
    private static int number = 0;

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


        new Thread(()->{//线程A
            while(number == 0){//从主内存中拿到number
			// while里面什么也没有
			// System.out.println("..."); 
//这里一刷新，println里面有同步代码块，会立即同步，一刷新就会回去加载主内存数据
//在循环体打印输出语句的，println方法中有synchronized同步代码块，
// 而synchronized也能保证对变量的修改可见性，对变量num进行操作以后，num的值也是立即刷回主存

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

        TimeUnit.SECONDS.sleep(1);

        number = 1; //主内存中number值变了，但线程A不知道，所以线程A无法结束while循环
        System.out.println("main=>number="+ number);
    }


}

17. volatile

17.1、保证可见性

一个线程对共享变量做了修改之后，其他的线程立即能够看到（感知到）该变量的这种修改（变化）。

package com.badwei.volatiletest;

import java.util.concurrent.TimeUnit;

public class JMMDemo {
    private volatile static int number = 0;
    // volatile 强制保证可见性

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


        new Thread(()->{//线程A
            while(number == 0){//从主内存中拿到number

//                System.out.println("..."); //这里一刷新，println里面有同步代码块，会立即同步，一刷新就会回去加载主内存数据
                //在循环体打印输出语句的，println方法中有synchronized同步代码块，
                // 而synchronized也能保证对变量的修改可见性，对变量num进行操作以后，num的值也是立即刷回主存

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

        TimeUnit.SECONDS.sleep(1);

        number = 1; //主内存中number值变了，但线程A不知道，所以线程A无法结束while循环
        System.out.println("main=>number="+ number);
    }


}

17.2、不保证原子性

原子性：不可分割

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

执行下方代码，输出结果不是20000；得出结论：volatile不保证原子性

package com.badwei.volatiletest;

public class VDemo02 {

    // volatile 不保证原子性
    private volatile static int num = 0;

    // add()这里加synchronized 可以保证原子性
    public static void add(){
        num++; //不是一个原子性操作
    }

    public static void main(String[] args) {

        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while(Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(num);
    }
}

为什么num++不是一个原子性操作：

如果不加lock和synchronized ，怎么样保证原子性？

使用原子类

使用原子类测试：【输出20000，保证了原子性】

package com.badwei.volatiletest;

import java.util.concurrent.atomic.AtomicInteger;

public class VDemo02 {

    // volatile 不保证原子性
    // 原子类的Integer
    private volatile static AtomicInteger num = new AtomicInteger(0);

    // add()这里加synchronized 可以保证原子性
    public static void add(){
//        num++; //不是一个原子性操作
        num.getAndIncrement(); //getAndIncrement 执行+1 方法  原理：CAS
        //底层和操作系统挂钩，在内存中修改值，Unsafe类是一个很特殊的存在
    }

    public static void main(String[] args) {

        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while(Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(num);
    }
}

底层和操作系统挂钩，在内存中修改值，Unsafe类是一个很特殊的存在

17.3、禁止指令重排，有序性

什么是指令重排？

我们写的程序，计算机并不是按照我们自己写的那样去执行的

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

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

as-if-serial语义

as-if-serial语义的意思指：不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不能被改变。编译器，runtime 和处理器都必须遵守as-if-serial语义。

int x=1; //1
int y=2; //2
x=x+5;   //3
y=x*x;   //4

//我们期望的执行顺序是 1_2_3_4  可能执行的顺序会变成2134 1324
//可不可能是 4123？ 不可能的

可能造成的影响结果：前提：a b x y这四个值默认都是0

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

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

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

指令重排后，可能在线程A中会出现，先执行b=1,然后再执行x=a；

在B线程中可能会出现，先执行a=2，然后执行y=b；

那么就有可能导致==诡异==结果如下：x=2; y=1.

例：

public class TTT2329 {
    static class State {
        int a = 0, b = 0, c = 0;
    }

    public static void main(String[] args) throws InterruptedException{
        for (int i=0; i<1000_0000; ++i) {
            final State state = new State();

            // write
            new Thread(() -> {
                state.a = 1;
                state.b = 1;
                state.c = state.a + 1;
            }).start();

            // read
            new Thread(() -> {
                int tmpC = state.c, tmpB = state.b, tmpA = state.a;
                if (tmpB == 1 && tmpA == 0) {
                    System.out.println("WTF, b == 1 && a == 0");
                } else if (tmpC == 2 && tmpB == 0) {
                    System.out.println("WTF, c == 2 && b == 0");
                } else if (tmpC == 2 && tmpA == 0) {
                    System.out.println("WTF, c == 2 && a == 0");
                }
            }).start();
        }
        System.out.println("done");
    }
}

循环一千万次，会出现一次指令重排。

volatile 可以避免指令重排

volatile中会加一道内存的屏障，这个内存屏障可以保证在这个屏障中的指令顺序。

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

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

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

17.4、总结

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

面试官：那么你知道在哪里用这个内存屏障用得最多呢？单例模式

18、单例模式

饿汉式 DCL懒汉式

饿汉式

package com.badwei.single;
/**
 * 饿汉式单例
 */
public class Hungry {

    private Hungry(){

    }
    // 可能会浪费空间
    private final static Hungry hungry = new Hungry();

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

浪费空间Demo

package com.badwei.single;

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

    private Hungry(){

    }
    // 可能会浪费空间
    private final static Hungry hungry = new Hungry();

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

懒汉式单例

package com.badwei.single;

/**
 * 懒汉式单例
 */
public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName() + "ok");

    }

    // 这里加volatile,保证原子性，防止指令重排
    private volatile static LazyMan lazyMan;

    //双重检测锁模式 的懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan==null){ //先判断，效率高
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); // 不是一个原子性操作
                    /**
                     * 1、分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     *
                     * 就有可能出现指令重排问题
                     *  正常：     132
                     *  可能会出现：132
                     *       线程A可能执行132
                     *       线程A执行到3的时候,此时线程B执行到if,发现不等于null,直接返回,但此时线程A还没有执行2,也就是说lazyMan还没有完成构造
                     *
                     *  我们就可以添加volatile保证指令重排问题
                     */
                }
            }
        }
        return lazyMan;
    }

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


}

静态内部类实现

也存在问题

package com.badwei.single;

/**
 * 静态内部类实现
 */
public class Holder {
    private Holder(){

    }

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

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

    }
}

破坏单例模式【例懒汉式】

1、下面这个代码，单例模式被破坏【通过反射创建了新的对象】

package com.badwei.single;

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

/**
 * 懒汉式单例
 */
public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName() + "ok");//输出了两次mainok
    }

    // 这里加volatile,保证原子性，防止指令重排
    private volatile static LazyMan lazyMan;

    //双重检测锁模式 的懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan==null){ //先判断，效率高
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); // 不是一个原子性操作
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);  
        System.out.println(instance2);
        // 两个对象不同, 单例模式被破坏

    }
}

输出j结果：

mainok
mainok
com.badwei.single.LazyMan@7f31245a
com.badwei.single.LazyMan@6d6f6e28

修改代码【构造器中加入锁】

package com.badwei.single;

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

/**
 * 懒汉式单例
 */
public class LazyMan {

    private LazyMan(){
        synchronized (LazyMan.class){ //这里再次进行加锁
            if (lazyMan!=null){
                throw new RuntimeException("不要试图使用反射来破坏单例异常");
            }
        }
        System.out.println(Thread.currentThread().getName() + "ok");


    }

    // 这里加volatile,保证原子性，防止指令重排
    private volatile static LazyMan lazyMan;

    //双重检测锁模式 的懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan==null){ //先判断，效率高
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); // 不是一个原子性操作
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance2 = declaredConstructor.newInstance();

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

    }

}

输出结果：

mainok
Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at com.badwei.single.LazyMan.main(LazyMan.java:56)
Caused by: java.lang.RuntimeException: 不要试图使用反射来破坏单例异常
	at com.badwei.single.LazyMan.<init>(LazyMan.java:14)
	... 5 more

暂时解决。

2、而下面这段代码，又破坏了单例模式【两个反射对象】

package com.badwei.single;

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

/**
 * 懒汉式单例
 */
public class LazyMan {

    private LazyMan(){
        synchronized (LazyMan.class){
            if (lazyMan!=null){
                throw new RuntimeException("不要试图使用反射来破坏单例异常");
            }
        }
        System.out.println(Thread.currentThread().getName() + "ok");


    }

    // 这里加volatile,保证原子性，防止指令重排
    private volatile static LazyMan lazyMan;

    //双重检测锁模式 的懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan==null){ //先判断，效率高
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); // 不是一个原子性操作
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);  
        System.out.println(instance2); 
        // 两个对象不同, 单例模式被破坏

    }
}

输出结果：

mainok
mainok
com.badwei.single.LazyMan@7f31245a
com.badwei.single.LazyMan@6d6f6e28

再次修改代码，【加入一个自定义布尔值判断】

package com.badwei.single;

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

/**
 * 懒汉式单例
 */
public class LazyMan {

    private static boolean lxw = false; //自定义布尔值

    private LazyMan(){
        synchronized (LazyMan.class){
            if (!lxw){
                lxw = true;
            }else{
                throw new RuntimeException("不要试图使用反射来破坏单例异常");
            }
        }
        System.out.println(Thread.currentThread().getName() + "ok");


    }

    // 这里加volatile,保证原子性，防止指令重排
    private volatile static LazyMan lazyMan;

    //双重检测锁模式 的懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan==null){ //先判断，效率高
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); // 不是一个原子性操作
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);  
        System.out.println(instance2); 
        // 两个对象不同, 单例模式被破坏

    }
}

输出结果：

mainok
Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at com.badwei.single.LazyMan.main(LazyMan.java:60)
Caused by: java.lang.RuntimeException: 不要试图使用反射来破坏单例异常
	at com.badwei.single.LazyMan.<init>(LazyMan.java:18)
	... 5 more

3、再次破坏【知道你用了lxw这个变量，通过反射手动修改这个值来破坏单例】

package com.badwei.single;

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

/**
 * 懒汉式单例
 */
public class LazyMan {

    private static boolean lxw = false;

    private LazyMan(){
        synchronized (LazyMan.class){
            if (!lxw){
                lxw = true;
            }else{
                throw new RuntimeException("不要试图使用反射来破坏单例异常");
            }
        }
        System.out.println(Thread.currentThread().getName() + "ok");


    }

    // 这里加volatile,保证原子性，防止指令重排
    private volatile static LazyMan lazyMan;

    //双重检测锁模式 的懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan==null){ //先判断，效率高
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); // 不是一个原子性操作
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Field lxw = LazyMan.class.getDeclaredField("lxw");
        lxw.setAccessible(true);

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

        lxw.set(instance,false); // 通过反射把lxw再改成false
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
        // 两个对象不同, 单例模式被破坏

    }
}

输出结果：

mainok
mainok
com.badwei.single.LazyMan@6d6f6e28
com.badwei.single.LazyMan@135fbaa4

单例又又又被破坏了。。。

想办法创造一个不被破坏的单例

枚举天生单例

使用jad反编译：

反编译后的枚举类源码：发现反编译发现枚举类没有空参构造器，只有一个有参构造器(String,int)

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   EnumSingle.java

package com.badwei.single;


public final class EnumSingle extends Enum
{

    public static EnumSingle[] values()
    {
        return (EnumSingle[])$VALUES.clone();
    }

    public static EnumSingle valueOf(String name)
    {
        return (EnumSingle)Enum.valueOf(com/badwei/single/EnumSingle, name);
    }

    private EnumSingle(String s, int i)
    {
        super(s, i);
    }

    public EnumSingle getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingle INSTANCE;
    private static final EnumSingle $VALUES[];

    static 
    {
        INSTANCE = new EnumSingle("INSTANCE", 0);
        $VALUES = (new EnumSingle[] {
            INSTANCE
        });
    }
}

使用反射想要破坏单例模式

package com.badwei.single;

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

// enum 本身也是一个类
public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class MyTest{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
//        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);//反编译发现没有无参构造器
        //发现String，和int的有参构造器
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);//反编译发现没有无参构造器
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

//        EnumSingle instance2 = EnumSingle.INSTANCE;

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

    }
}

输出结果：报错，无法通过反射破坏enum的单例

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
	at com.badwei.single.MyTest.main(EnumSingle.java:22)

19、CAS

19.1、什么是CAS？

CAS：Compare and Swap，即比较再交换。

下面这个compareAndSet的底层是compareAndSwapInt

package com.badwei.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        // public final boolean compareAndSet(int expect, int update)
        // 如果期望值expect达到了, 就更新update, 否则就不更新
        boolean b1 = atomicInteger.compareAndSet(2020, 2021);
        System.out.println(b1);
        System.out.println(atomicInteger.get());
        boolean b2 = atomicInteger.compareAndSet(2020, 2021);
        System.out.println(b2);
        System.out.println(atomicInteger.get());
    }
}

Unsafe类

19.2、总结

CAS：比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环，使用的是自旋锁

缺点：

循环会耗时；
一次性只能保证一个共享变量的原子性；
它会存在ABA问题

CAS中的ABA问题(狸猫换太子)

线程1：期望值是1，要变成2；

线程2：两个操作：线程2快

第一步：期望值是1，变成3
第二步：期望是3，变成1

所以对于线程1来说，A的值还是1，所以就出现了ABA问题，骗过了线程1；

20、原子引用

带版本号的原子操作！

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

带版本号的原子操作

package com.badwei.cas;

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

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

        // AtomicStampedReference 注意: 如果泛型是一个包装类，注意泛型的引用问题
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(20, 1);

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp(); // 获得版本号
            System.out.println("A1=>"+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(20, 22, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("A2=>"+atomicStampedReference.getStamp());
            System.out.println(atomicStampedReference.compareAndSet(22, 20, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("A3=>"+atomicStampedReference.getStamp());
        },"A").start();


        // 乐观锁的原理相同,版本号不同，就不修改
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp(); // 获得版本号
            System.out.println("B1=>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(20, 66, stamp, stamp + 1));
            System.out.println("B2=>"+atomicStampedReference.getStamp());
        },"B").start();


    }
}

输出：

A1=>1
B1=>1
true
A2=>2
true
false
B2=>3
A3=>3

21、各种锁的理解

21.1、公平锁，非公平锁

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

2、非公平锁：非常不公平，允许插队，可以改变顺序（默认都是非公平）

//默认的非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}

//重载方法,true,公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

21.2、可重入锁

1.Synchonized 锁

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

}

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

2.Lock锁

//lock
public class Demo02 {

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

}
class Phone2{

    Lock lock=new ReentrantLock();

    public void sms(){
        lock.lock(); //细节：这个是两把锁，两个钥匙
        //lock锁必须配对，否则就会死锁在里面
        try {
            System.out.println(Thread.currentThread().getName()+"=> sms");
            call();//这里也有一把锁
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void call(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "=> call");
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
}

21.3、自旋锁

1.spinlock

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

2.自我设计自旋锁

package com.badwei.lock;

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

public class SpinlockDemo {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();

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

        while(!atomicReference.compareAndSet(null,thread)){
            System.out.println(Thread.currentThread().getName() + "自旋中");
            try {
                TimeUnit.MILLISECONDS.sleep(200); // 200毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

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

    
}

测试

package com.badwei.lock;


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

public class SpinLockTest {
    public static void main(String[] args) throws InterruptedException {
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();


        SpinlockDemo lock = new SpinlockDemo();

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.myUnLock();
            }

        },"T1").start();

        TimeUnit.SECONDS.sleep(1);

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

        },"T2").start();



    }
}

输出结果：【T1解锁完之后，T2才解锁】

原理：在atomicreference操作完T1之后，T2拿到atomicreference开始自旋，进入休眠3秒，3秒T1结束执行解锁，跳出自旋

T1 -> lock

T2 -> lock

T1 -> unlock

T2 -> unlock

T1==> mylock
T2==> mylock
T2自旋中
T2自旋中
T2自旋中
T2自旋中
T2自旋中
T2自旋中
T2自旋中
T2自旋中
T2自旋中
T2自旋中
T1==> myUnlock
T2==> myUnlock

21.4、死锁

请问进程调度中产生死锁的必要条件是什么？解决死锁有几种办法

答：
产生死锁的四个必要条件：
（1）互斥条件：一个资源每次只能被一个进程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

死锁排除的方法:
（1）撤消陷于死锁的全部进程；
（2）逐个撤消陷于死锁的进程，直到死锁不存在；
（3）从陷于死锁的进程中逐个强迫放弃所占用的资源，直至死锁消失。
（4）从另外一些进程那里强行剥夺足够数量的资源分配给死锁进程，以解除死锁状态。

死锁demo：

package com.badwei.lock;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA= "lockA";
        String lockB= "lockB";

        new Thread(new MyThread(lockA,lockB),"T1").start(); //T1拿着锁lockA 想获取lockB
        new Thread(new MyThread(lockB,lockA),"T2").start(); //T2拿着锁lockB 想获取lockA
        // 死锁
    }
}

class MyThread implements Runnable{

    private String lockA;
    private String lockB;

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

    @Override
    public void run() {

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

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

    }
}

如何查找死锁

查看堆栈信息

1、使用jps定位进程号，jdk的bin目录下：有一个jps

命令：jps -l

2、使用jstack 进程进程号找到死锁信息

juc高并发进阶

juc高并发进阶

1、什么是JUC

2、线程和进程

2.1、进程线程：

2.2、并发，并行

2.3、线程的状态

2.4、wait/sleep区别

3、Lock

3.1、传统的 synchronized

3.2、Lock

3.3、syschronized和Lock的区别

4、生产者和消费者问题

4.1、Synchronized版 wait notify

4.2、if存在问题（虚假唤醒）

4.3、Lock版

4.4、Condition的优势

5、8锁问题

问题1

问题2：

问题3

问题4

问题5、6

问题7、8

6、集合类不安全

List 不安全

set 不安全

Map不安全

7. Callable

8、常用辅助类

8.1、CountDownLatch

8.2、CyclickBarrier

8.3、Semaphore

9、读写锁

10、阻塞队列

10.1、BlockQueue

10.2、Synchronized 同步队列

11、线程池（重点）

11.1、线程池的好处：

11.2、线程池：三大方法

11.3、七大参数

11.4、拒绝策略

11.5、自定义线程池ThreadPoolExecutor

11.6、如何设置线程池的大小(调优)

12、四大函数式接口*

12.1、什么是函数式接口

Function函数型接口

Predicate断定型接口

Consumer消费性接口

Supplier供给型接口

13、Stream流式计算

14、ForkJoin

14.1、ForkJoin 特点： 工作窃取！

14.2、如何使用ForkJoin?

Java8的Stream并行流底层使用了ForkJoin框架

15、异步回调

15.1、没有返回值的runAsync异步回调

15.2、有返回值的异步回调supplyAsync

16、JMM

请你谈谈你对Volatile的理解

什么是JMM

17. volatile

17.1、保证可见性

17.2、不保证原子性

17.3、禁止指令重排，有序性

17.4、总结

18、单例模式

饿汉式

懒汉式单例

静态内部类实现

破坏单例模式【例懒汉式】

1、下面这个代码，单例模式被破坏【通过反射创建了新的对象】

2、而下面这段代码，又破坏了单例模式【两个反射对象】

3、再次破坏【知道你用了lxw这个变量，通过反射手动修改这个值来破坏单例】

19、CAS

19.1、什么是CAS？

19.2、总结

20、原子引用

21、各种锁的理解

21.1、公平锁，非公平锁

14.1、ForkJoin 特点：工作窃取！