JUC Study

JUC Study

java.util.concurrent(juc)

三个interfaces：Condition、Lock、ReadWriteLock

1、进程和线程

1.1 进程：一个程序

一个进程往往可以包含多个线程，至少包含一个！

Java默认有几个进程？ 2个，main进程和GC（垃圾回收机制）进程

对于Java而言：Thread、Runnable、Callable

1.2 Java真的可以开启线程吗？

public synchronized void start() {
 
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    group.add(this);
    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
        }
    }
}

//本地方法，调用底层的c++，Java无法直接操作硬件
private native void start0();

1.3 并行并发

并发编程：并发、并行

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

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

并行（多个人一起行走）

• CPU多核，多个线程可以同时进行

package com.ngk.demo01;

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

//result 12

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

1.5 线程的几个状态

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

1.6 wait/sleep的区别

1.来自不同的类

wait–> Object

sleep–>Thread

2.关于锁的释放

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

3.使用范围

wait：必须在同步代码块中

sleep：可以在任何地方

4.是否需要捕获异常

wait不需要捕获异常，sleep需要捕获异常

2、Lock锁（重点）

2.1 传统的开发方式：

package com.ngk.demo01;
/*
    线程就是一个单独的资源类，没有任何附属的操作
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //并发，多线程操作同一个资源类，把资源丢入线程
        Ticket ticket = new Ticket();

        //@FunctionalInterface 函数式接口，jdk1.8 lamda表达式(参数)->{代码}
        new Thread(()->{
            for (int i = 1; i < 40; i++){
                ticket.sales();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i < 40; i++){
                ticket.sales();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 1; i < 40; i++){
                ticket.sales();
            }
        },"C").start();
    }
}
//资源类 OOP思想
class Ticket{
   //属性、方法
    private int number = 30;

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

oop思想：面向对象编程（Object Oriented Programming，OOP）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。核心思想：封装，继承，多态，OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。

2.2 Lock接口

package com.ngk.demo01;

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

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发，多线程操作同一个资源类，把资源丢入线程
        Ticket2 ticket = new Ticket2();
        //@FunctionalInterface 函数式接口，jdk1.8 lamda表达式(参数)->{代码}
        new Thread(()->{for (int i = 1; i < 40; i++){ticket.sales();}},"A").start();
        new Thread(()->{for (int i = 1; i < 40; i++){ticket.sales();}},"B").start();
        new Thread(()->{for (int i = 1; i < 40; i++){ticket.sales();}},"C").start();
    }
}

//lock三部曲
//1、new ReentrantLock();
//2、lock.lock();    //加锁
//3、finally==> lock.unlock();   //解锁
class Ticket2{
   //属性、方法
    private int number = 30;

    Lock lock = new ReentrantLock();

    //卖票的方式
    //synchronized 本质：队列，锁
    public  void sales(){
        lock.lock();    //加锁

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

公平锁和非公平锁

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

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

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

2.3 Lock和Synchronized的区别

1、Synchronized是Java内置关键字，Lock是一个Java类

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

3、Synchronized会自动释放锁，Lock必须要手动释放锁，如果不释放，就会造成死锁

4、Synchronized线程1（获得锁，阻塞）、线程2（等待），Lock锁就不一定会等下去

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

6、Synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码问题。

3、生产者和消费者问题

3.1 生产者和消费者问题 Synchronized

package com.ngk.pc;

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

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

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

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

//等待，业务， 通知
class Data{ //数字，资源类
    private int number = 0;
    //+1
    public synchronized void increament() throws InterruptedException {
        if(0!=number){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"-->"+number);
        //通知其他线程，+1完毕
        this.notifyAll();
    }
    //-1
    public synchronized void decreament() throws InterruptedException {
        if(0==number){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"-->"+number);
        //通知其他线程，-1完毕
        this.notifyAll();
    }
}

问题存在：A B C D四个线程

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

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

if 判断改为where判断，防止虚假唤醒

package com.ngk.pc;

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

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

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

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

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

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

//等待，业务， 通知
class Data{ //数字，资源类
    private int number = 0;
    //+1
    public synchronized void increament() throws InterruptedException {
        while(0!=number){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"-->"+number);
        //通知其他线程，+1完毕
        this.notifyAll();
    }
    //-1
    public synchronized void decreament() throws InterruptedException {
        while(0==number){	//防止虚假唤醒
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"-->"+number);
        //通知其他线程，-1完毕
        this.notifyAll();
    }
}

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

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

代码实现

package com.ngk.pc;

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

/*
*   线程之间的通信问题：生产者、消费者问题！  等待唤醒，等待通知
*   A num+1
*   B num-1
 */
public class ProducerCustomer2 {
    public static void main(String[] args) {
        Data2 data2 = new Data2();

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

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

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

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data2.decreament();
                } 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();  //唤醒全部

    //+1
    public void increament() 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();
        }
    }
    //-1
    public void decreament() 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();
        }
    }

}

任何一个新的技术，绝对不是仅仅覆盖了原来的技术，优势和补充

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

package com.ngk.pc;

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

/*
*   a->b b->c c->a...
 */
public class ProducerCustomer3 {

    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 Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1;
    public void printA(){
        lock.lock();
        try {
            //业务，判断-》执行-》通知
            while(1 != number){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"-->AAA");
            number = 2 ;
            //唤醒，指定的人B
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            //业务，判断-》执行-》通知
            while (2 != number){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"-->BBB");
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            //业务，判断-》执行-》通知
            while (3 != number){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"-->CCC");
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    //生产线：下单->支付->交易->物流
}

4、8锁现象

如何判断锁的是谁？永远知道什么锁，锁的是谁！

深刻理解我们的锁

package com.ngk.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 标准情况下：1、发短信  2、打电话
 * 两个对象先打电话还是先发短信 -->发短信
 */
public class Test1 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();

        //锁的存在
        new Thread(()->{phone1.sendSms(); },"A").start();
        new Thread(()->{phone1.call();},"B").start();
    }
}
class Phone1{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁执行
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms...");   //发短信
    }
    public synchronized void call(){
        System.out.println("call...");  //打电话
    }
}

package com.ngk.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 标准情况下：1、发短信  2、打电话
 * 增加一个普通方法之后,一个对象：先执行发短信还是hello --> hello
 * 两个对象先打电话还是先发短信   -->先执行普通方法
 */
public class Test2 {
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        //锁的存在
        new Thread(()->{
           phone1.sendSms();
        },"A").start();


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

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

    public void hello(){
        System.out.println("hello......");
    }
}

package com.ngk.lock8;

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 * 增加两个静态的同步方法，先打印发短信还是打电话？-->同一对象，谁先拿到就锁谁
 */
public class Test3 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        //锁的存在
        new Thread(()->{ phone1.sendSms(); },"A").start();

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

class Phone3{
    //synchronized 锁的对象是方法的调用者
    //static 静态方法
    //类一加载就有了，class模板，锁的是class
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms...");   //发短信
    }
    public static synchronized void call(){
        System.out.println("call...");  //打电话
    }
}

package com.ngk.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 1个静态同步方法，一个普通同步方法 一个对象-->先打印普通同步方法
 * 1个静态同步方法，一个普通同步方法 两个对象-->先打印普通同步方法
 * */
public class Test4 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        //锁的存在
        new Thread(()->{ phone1.sendSms(); },"A").start();

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

小结：

new this 具体的一个手机

static Class 唯一的一个模板

5、CopyWriteArrayList

解决方案：最优使用CopyWriteArrayList<>()

package com.ngk.unsafe;

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

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

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

CopyWriteArrayList.add方法原理：使用了Lock锁

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

6、CopyWriteSet

package com.ngk.unsafe;

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、Set<String> set = Collections.synchronizedSet(new HashSet<>());
//2、Set<String> set = new CopyOnWriteArraySet<>();
public class TestSet {
    public static void main(String[] args) {
        //Set<String> set = new HashSet<>();
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

HashSet的底层：

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

//add(),本质是map，key是无法重复的
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

7、ConCurrentHashMap

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

package com.ngk.unsafe;

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

//java.util.ConcurrentModificationException 并发修改异常
public class TestMap {
    public static void main(String[] args) {
        //new HashMap<>() more能等价于new new HashMap<>(16，0.75)    //加载因子和初始化容量
        Map<String, String> map = new ConcurrentHashMap<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

8、Callable（简单）

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

代码测试：

package com.ngk.callable;

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

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

        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread); //适配类
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();

        //接受返回的结果
        String str = (String) futureTask.get(); //可能会产生阻塞，把他放到异常，或者使用异步通信处理
        System.out.println(str);
    }
}

class MyThread implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("call.......");
        return "123";
    }
}

//可能会产生阻塞，把他放到异常，或者使用异步通信处理
futureTask.get(); 

细节：

1、有缓存

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

9、常用辅助类（必会）

9.1、CountDownLatch

减法计数器

package com.ngk;

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 = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"Go out...");
                countDownLatch.countDown(); //数量-1
            },String.valueOf(i)).start();
        }
        countDownLatch.await(); //等待计数器归零，然后向下执行
        System.out.println("Close Door...");
    }
}

原理：

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

countDownLatch.await()； //等待计数器归零，然后向下执行

每次有线程调用countDown()-1，假设计数器为零，**countDownLatch.await()**就会被唤醒向下继续执行。

9.2、CyclicBarrier

package com.ngk.add;

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

//加法计数器
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("召唤神龙成功！");
        });
        for (int i = 1; i <= 7; i++) {
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集到"+temp+"号龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

9.3、Semaphore

Semaphore：信号量

package com.ngk.add;

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

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        //线程数量：停车位 
        //应用场景：限流
        for (int i = 1 ; i <= 6; i++) {
            new Thread(()->{
                //acquire   得到
                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();    //release   释放
                }
            }).start();
        }
    }
}

原理：

semaphore.acquire(); 获得，假设如果已经满了，就会进行等待，直到被释放为止

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

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

10、读写锁

ReadWriteLock

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

package com.ngk.rw;

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

/**
 * 独占锁（写锁）一次只能被一个线程占有
 * 共享锁（读锁）多个线程可以同时拥有
 * ReadWriteLock
 * 读-读 可以共存
 * 读-写 不能共存
 * 写-写 不能共存
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache cache = new MyCache();
        //写入
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                cache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        //取出
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                cache.get(temp+"");
            },String.valueOf(i)).start();
        }
    }
}
/**
 * 自定义缓存
 */
class MyCache{
    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()+"写入...");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName()+"写入完毕...");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            readWriteLock.writeLock().unlock();
        }
    }
    //取，读,所有人都可以读
    public void get(String key){
        readWriteLock.readLock().lock();

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

    }
}

11、阻塞队列

写入：如果队列满了，就必须进行阻塞等待

取出：如果队列是空的，必须阻塞等待生产

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

BlockingQueue

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

阻塞队列的使用场景：多线程并发处理，线程池

四组API

1、抛出异常

添加：add()

删除：remove()

检测队首元素：element()

public static void test1(){
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
    System.out.println(blockingQueue.add("A"));
    System.out.println(blockingQueue.add("B"));
    System.out.println(blockingQueue.add("C"));
    //IllegalStateException: Queue full 抛出异常
    //System.out.println(blockingQueue.add("D"));
    System.out.println("===================");
    System.out.println(blockingQueue.remove());
    System.out.println(blockingQueue.remove());
    System.out.println(blockingQueue.remove());
    //java.util.NoSuchElementException
    System.out.println(blockingQueue.remove());
}

2、不会抛出异常

添加：offer()

删除：poll()

检测队首元素：peek()

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"));
    System.out.println(blockingQueue.offer("D"));
    
    System.out.println("===================");
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    //java.util.NoSuchElementException
    System.out.println(blockingQueue.poll());   //null 不抛出异常
}

3、阻塞等待

添加：put()

删除：take()

public static void test3() throws InterruptedException {
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
    //一直阻塞
    blockingQueue.put("A");
    blockingQueue.put("B");
    blockingQueue.put("C");
    //blockingQueue.put("D");
    //blockingQueue.put("D")队列没有位置了，一直阻塞
    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take());
    //System.out.println(blockingQueue.take());   //没有这个元素，一直阻塞
}

4、超时等待

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));//等待超过两秒就退出
    System.out.println("===================");
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll(2,TimeUnit.SECONDS));//等待超过两秒就退出
}

12、同步队列

SynchronizedQueue

package com.ngk.bq;

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

/**
 * 同步队列
 * 和其他的BlockingQueue不一样，SynchronizedQueue不存储元素
 * put了一个元素，必须先从里面take取出来，否则不能再out进去值
 */

public class SynchronizedQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new SynchronousQueue<String>(); //同步队列

        new Thread(()->{
            try {
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName()+"put1");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName()+"put2");
                blockingQueue.put("3");
                System.out.println(Thread.currentThread().getName()+"put3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T1").start();

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

12、线程池（重点）

池化技术

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

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

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

线程池的好处：

1、降低资源的消耗

2、提高响应的速度

3、方便管理

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

12.1、三大方法

package com.ngk.pool;

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

//Executors 工具类，三大方法
public class Demo1 {
    public static void main(String[] args) {
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
        //ExecutorService threadPool = Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小
        ExecutorService threadPool =Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱
        try {
            for (int i = 0; i < 100; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "ok...");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

12.2 七大参数

源码分析

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,	
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}
Th

//本质：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;
}

12.3 七个参数的使用

package com.ngk.pool;

import java.util.concurrent.*;
//Executors 工具类，三大方法，七大参数
public class Demo1 {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());  //队列满了，还有数据进来，不处理这个数据，抛出异常
                //new ThreadPoolExecutor.CallerRunsPolicy());//哪里来的去哪里
                //new ThreadPoolExecutor.DiscardOldestPolicy());//队列满了，丢掉任务，不会抛出异常
                //new ThreadPoolExecutor.DiscardPolicy());//尝试和最早的竞争，也不会抛出异常
        try {
            //最大承载：Deque + Max
            //超出 java.util.concurrent.RejectedExecutionException
            for (int i = 1; i <= 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "ok...");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

12.4 四种拒绝策略

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

12.5 小结和拓展

池的最大的大小如何去设置？

IO密集型、CPU密集型（调优）

package com.ngk.pool;

import java.util.concurrent.*;
//Executors 工具类，三大方法，七大参数
public class Demo1 {
    public static void main(String[] args) {

        //最大线程到底该如何定义
        //1、CPU密集型，几核就是几，可以保持CPU的效率最高
        //2、IO密集型，判断程序中十分好资源的线程，io十分的耗资源

        //获取CPU的核数
        System.out.println(Runtime.getRuntime().availableProcessors());
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()); 
        try {
           java.util.concurrent.RejectedExecutionException
            for (int i = 1; i <= 8; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "ok...");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

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

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

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

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

13.1、Function函数型接口

//T传入类型，R返回类型
public interface Function<T, R> {
    R apply(T t);
}

代码测试：

package com.ngk.function;

import java.util.function.Function;

public class Demo01 {
    public static void main(String[] args) {
        //@FunctionalInterface
        //public interface Function<T, R>   //T传入类型，R返回类型
        /*Function function = new Function<String, String>() {
            @Override
            public String apply(String str) {
                return str;
            }
        };*/

        //lambda 方式
        Function function = (str)->{return str;};
        System.out.println(function.apply("msg"));
    }
}

13.2、Predecate

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

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

package com.ngk.function;

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

13.3、Consumer 消费型接口

//只有输入没有返回值
public interface Consumer<T> {
    void accept(T t);
}

代码测试：

package com.ngk.function;

import java.util.function.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);
            }
        };*/
        Consumer<String> consumer = (str)->{System.out.println(str);};
        consumer.accept("luhan");
    }
}

13.4 、Supplier 供给型接口

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

代码测试：

package com.ngk.function;

import java.util.function.Supplier;

/**
 * 供给型接口，没有参数，只有返回值
 */
public class Demo04 {
    public static void main(String[] args) {
        /*Supplier supplier = new Supplier() {
            @Override
            public Object get() {
                return 1024;
            }
        };*/
        Supplier supplier = ()->{return 1024;};
        System.out.println(supplier.get());
    }
}

14、Stream流式计算

什么是Stream流式计算？

大数据：存储+计算

集合：Mysql本质就是存储东西的

计算都应该交给流来操作

代码实现：

package com.ngk.stream;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;
}

package com.ngk.stream;

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

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

        //集合就是存储
        List<User> list = Arrays.asList(u1,u2,u3,u4,u5,u6);
        //计算交给Stream流
        list.stream()
                .filter(u->{return u.getId()%2==0;})    //过滤ID为单数的数据
                .filter(u->{return u.getAge()>23;}) //返回年龄大于23岁的数据
                .map(u->{return u.getName().toUpperCase();})   //字符串转大写
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                .limit(1)   //只输出一个数据
                .forEach(System.out::println);
    }
}

15、ForkJoin

forkjoin在JDK1.7，并行执行任务！提高效率，大数据量时使用

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

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

ForkJoin特点：工作窃取

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

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

代码实现1到10_0000_0000的和：

package com.ngk.forkjoin;

import java.util.concurrent.RecursiveTask;

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)>>1; //中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork();  //拆分任务，把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
            task2.fork();  //拆分任务，把任务压入线程队列

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

package com.ngk.forkjoin;

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

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        test1();    //sum = 500000000500000000 时间：5646
        test2();    //sum = 500000000500000000 时间：3300
        test3();    //sum = 500000000500000000 时间：119
    }

    //暴力方法
    public static void test1(){
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= 10_0000_0000; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum = "+sum+" 时间："+(end-start));
    }

    //forkjoin方法
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);  //提交任务
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum = "+sum+" 时间："+(end-start));
    }

    //Stream并行流
    public static void test3(){
        long start = System.currentTimeMillis();
        //Stream 并行流() (]
        long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum = "+sum+" 时间："+(end-start));
    }
}

16、异步回调

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

package com.ngk.future;

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()+"runAsyc=>Void");
        });
        System.out.println("1111");
        completableFuture.get();*/

        //有返回值的supplyAsync的异步回调
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
            int i = 1/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());
    }
}

17、JMM

17.1、谈谈对Volatile的理解

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

1、保证可见性

2、不保证原子性

3、禁止指令指令重排

17.2、什么是JMM

JMM：java内存模型，不存在的东西，它是一种概念，也是一种约定

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

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

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

18、Volatile

18.1、保证可见性

package com.ngk.tvolatile;

import java.util.concurrent.TimeUnit;

public class JMMDemo {
    //不加volatile，程序就会死循环
    //加volatile，可以保证可见性
    private volatile static int num = 0;

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

           }
        }).start();

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

18.2、不保证原子性

原子性：不可分割

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

package com.ngk.tvolatile;

//不保证原子性
public class VDemo02 {
    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 = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

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

运行结果：main 18519

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

添加一个原子类AtomicInteger

package com.ngk.tvolatile;

import java.util.concurrent.atomic.AtomicInteger;

//不保证原子性
public class VDemo02 {
    //原子类的Integer
    private volatile static AtomicInteger num = new AtomicInteger();
    public static void add(){
       // num++;    //不是一个原子性的操作
        num.getAndIncrement();//AtomicInteger + 1 方法    CAS
    }
    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

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

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

18.4、指令重排

• 什么是指令重排：

volatile可以避免指令重排

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

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

18.5 Volatile小结

Volatile是可以保持可见性，不能保证原子性，由于内存屏障，可以避免指令重排的现象产生。（单例模式使用的最多）

19、单例模式

饿汉模式：

package com.ngk.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 getHungry(){
        return HUNGRY;
    }
}

懒汉模式：

package com.ngk.single;
//懒汉式单例
public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+" ok!");
    }
    private volatile static LazyMan lazyMan;

    //双重检测锁模式 懒汉式单例 DCL懒汉式
    public static LazyMan getLazyMan(){
        if(null == lazyMan){
            synchronized (LazyMan.class){
                if(null ==lazyMan){
                    lazyMan = new LazyMan();    //不是一个原子性的操作
                    /**
                     * 1、分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     */
                }
            }
        }
        return lazyMan; //lazyMan可能还没有完成构造,所以需要在属性加上volatile，保证指令不能重排，进行原子性的操作
    }

    //多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getLazyMan();
            }).start();
        }
    }
}

静态内部类

package com.ngk.single;

//静态内部类
public class Holder {
    //构造器私有
    private Holder(){

    }

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

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

单例不安全，有反射

package com.ngk.single;

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

//懒汉式单例
public class LazyMan {

    private static boolean flag = false;

    private LazyMan(){
        synchronized (LazyMan.class){
            if(false == flag){
                flag = true;
            }else {
                throw new RuntimeException("不要试图使用反射破环异常");
            }
        }
    }
    private volatile static LazyMan lazyMan;

    //双重检测锁模式 懒汉式单例 DCL懒汉式
    public static LazyMan getLazyMan(){
        if(null == lazyMan){
            synchronized (LazyMan.class){
                if(null ==lazyMan){
                    lazyMan = new LazyMan();    //不是一个原子性的操作
                }
            }
        }
        return lazyMan; //lazyMan可能还没有完成构造,所以需要在属性加上volatile，保证指令不能重排，进行原子性的操作
    }

    //反射
    public static void main(String[] args) throws Exception {
        //反射可以破环单例
        /*LazyMan instance1 = LazyMan.getLazyMan();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);   //com.ngk.single.LazyMan@14ae5a5
        System.out.println(instance2);  //com.ngk.single.LazyMan@7f31245a*/
        //解决：在构造函数再设置一道锁
        /**
         *  synchronized (LazyMan.class){
         *        if(null != lazyMan){
         *           throw new RuntimeException("不要试图使用反射破环异常");
         *         }
         *  }
         */

        //反射可以破环单例
        /*Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance(); //使用同一对象生成
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);   //com.ngk.single.LazyMan@14ae5a5
        System.out.println(instance2);  //com.ngk.single.LazyMan@7f31245a*/

        //解决：设置一个特殊的标志属性private static boolean xxx = false;
        /*synchronized (LazyMan.class){
            if(false == xxx){
                xxx = true;
            }else {
                throw new RuntimeException("不要试图使用反射破环异常");
            }
        }*/

        //反射可以破环单例
        Field flag = LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance();
        flag.set(instance1, false);
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);   //com.ngk.single.LazyMan@14ae5a5
        System.out.println(instance2);  //com.ngk.single.LazyMan@7f31245a

        //解决：使用枚举，反射不能破坏枚举

    }
}

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

枚举

package com.ngk.single;

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

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

    public EnumSingle getInstancr(){
        return INSTANCR;
    }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        /*EnumSingle instancr1 = EnumSingle.INSTANCR;
        Constructor<EnumSingle> declaredConstructor= EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instancr2 = declaredConstructor.newInstance();

        //Exception in thread "main" java.lang.NoSuchMethodException: com.ngk.single.EnumSingle.<init>()
        //IDEA提示里面没有空参构造方法
        System.out.println(instancr1);
        System.out.println(instancr2);
        */

        //解决方案：
        /**
         * Constructor<EnumSingle> declaredConstructor= EnumSingle.class.getDeclaredConstructor(String.class, int.class);
         */

        EnumSingle instancr1 = EnumSingle.INSTANCR;
        Constructor<EnumSingle> declaredConstructor= EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instancr2 = declaredConstructor.newInstance();

        //IDEA提示里面没有空参构造方法
        System.out.println(instancr1);
        System.out.println(instancr2);

        //输出：Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects反射不能破环Enum的class
    }
}

20、深入理解CAS

20.1 什么是CAS？

package com.ngk.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

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

        //expect 期望
        //update 更新
        //public final boolean compareAndSet(int expect, int update)
        //如果期望的值达到了就进行更新,否则就不进行更新
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

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

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

Java的后门，可以通过unsafe类操作内存

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

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

小结：

CAS： compareAndSet 比较并交换，如果这个值期望的，那么则执行操作,否则就不是就一直循环（自旋锁）。

缺点：

1、循环会耗时

2、一次性只能保证一个共享变量的原子性

3、会存在ABA问题

21、原子引用解决ABA问题

ABA问题

ABA问题：ABA问题的根本在于cas在修改变量的时候，无法记录变量的状态，比如修改的次数，否修改过这个变量。这样就很容易在一个线程将A修改成B时，另一个线程又会把B修改成A,造成casd多次执行的问题

package com.ngk.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

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

        //expect 期望
        //update 更新
        //public final boolean compareAndSet(int expect, int update)
        //如果期望的值达到了就进行更新,否则就不进行更新
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        //======================================捣乱的线程
        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());
        //======================================期望的线程
        System.out.println(atomicInteger.compareAndSet(2020, 6666));
        System.out.println(atomicInteger.get());
    }
}

解决：原子引用

带版本号的原子操作

package com.ngk.cas;

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

public class CASDemo {

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

        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);

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

            atomicStampedReference.compareAndSet(2,1,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("a3-->"+stamp);
        },"a").start();

        //和乐观锁的原理相同
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();   //获得版本号
            System.out.println("b1-->"+stamp);

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

            atomicStampedReference.compareAndSet(1,6,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("b2-->"+atomicStampedReference.getStamp());
        },"b").start();
    }
}

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

22、理解各种锁

1、公平锁、非公平锁

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

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

//public final boolean compareAndSet(int expect, int update)
//如果期望的值达到了就进行更新,否则就不进行更新
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
//======================================捣乱的线程
System.out.println(atomicInteger.compareAndSet(2021, 2020));
System.out.println(atomicInteger.get());
//======================================期望的线程
System.out.println(atomicInteger.compareAndSet(2020, 6666));
System.out.println(atomicInteger.get());
}
}

#### 解决：原子引用

带版本号的原子操作

~~~java
package com.ngk.cas;

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

public class CASDemo {

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

        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);

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

            atomicStampedReference.compareAndSet(2,1,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("a3-->"+stamp);
        },"a").start();

        //和乐观锁的原理相同
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();   //获得版本号
            System.out.println("b1-->"+stamp);

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

            atomicStampedReference.compareAndSet(1,6,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("b2-->"+atomicStampedReference.getStamp());
        },"b").start();
    }
}

[外链图片转存中…(img-csPIDsv6-1598243066239)]

22、理解各种锁

1、公平锁、非公平锁

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

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

2、可重入锁