JUC由简入深学习

JUC学习

1.什么是JUC

java.util 工具包、包、分类

业务：普通的线程代码 Thread

Runnable 没有返回值、效率相比入 Callable 相对较低！

2.线程和进程

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

进程：一个程序，QQ.exe Music.exe 程序的集合；

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

Java默认有几个线程？ 2 个 mian、GC

线程：开了一个进程 Typora，写字，自动保存（线程负责的）

对于Java而言：Thread、Runnable、Callable

Java 真的可以开启线程吗？ 答：开不了

public synchronized void start() {

    /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
        * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */

    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
    group.add(this);
    boolean started = false;

    try {
        start0()
        started = true;

    } finally {

        try {
            if (!started) {
                group.threadStartFailed(this);
            }

        } catch (Throwable ignore) {

            /* do nothing. If start0 threw a Throwable then

                  it will be passed up the call stack */
        }
    }

}

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

并发、并行

并发编程：并发、并行

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

CPU 一核，模拟出来多条线程，天下武功，唯快不破，快速交替

并行（多个人一起行走）

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

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

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

线程有几个状态

public enum State {

    // 新生
    NEW,

    // 运行
    RUNNABLE,

    // 阻塞
    BLOCKED,
    
    // 等待，死死地等
    WAITING,

    // 超时等待
    TIMED_WAITING,

    // 终止
    TERMINATED;

}

wait/sleep 区别

1、来自不同的类

wait => Object

sleep => Thread

2、关于锁的释放

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

3、使用的范围是不同的

wait必须在同步代码块中

sleep可以在任何地方睡

4、是否需要捕获异常

wait 不需要捕获异常

sleep 必须要捕获异常

3.Lock锁(重点)

传统 Synchronized

package com.jihu;
// 基本的卖票例子

/**
 * 真正的多线程开发，公司中的开发，降低耦合性
 * 线程就是一个单独的资源类，没有任何附属的操作！
 * 1、 属性、方法
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {

        // 并发：多线程操作同一个资源类, 把资源类丢入线程
        Ticket ticket = new Ticket();
        // @FunctionalInterface 函数式接口，jdk1.8  lambda表达式 (参数)->{ 代码 }
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"A").start();

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

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


}

//资源类  OOP
class Ticket{
    //属性、方法
    private  int number = 10;

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

Lock 接口

公平锁：十分公平：可以先来后到非公平锁：

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

package com.jihu;

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();
        new Thread(()->{ for (int i = 0; i < 20; i++) { ticket.sale();}},"A").start();
        new Thread(()->{ for (int i = 0; i < 20; i++) { ticket.sale();}},"B").start();
        new Thread(()->{ for (int i = 0; i < 20; i++) { ticket.sale();}},"C").start();
    }

}

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

    Lock lock = new ReentrantLock();

    public  synchronized void  sale(){
        lock.lock(); //加锁
        lock.tryLock(); //加入后不会一直等下去，其他线程阻塞的话
        try {
            // 业务代码
            if (number > 0){
                System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票，剩余："+number);
            }
        }catch (Exception  e){
            e.printStackTrace();
        }finally {
            lock.unlock(); //解锁
        }
    }
}

Synchronized 和 Lock 区别

1.Synchronized 内置的java关键字，Lock是一个java类

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

3.Synchronized 会自动释放锁，lock必须手动释放锁，如果不释放锁，会导致死锁

4.Synchronized 线程1(获得锁，阻塞)、线程2(等待，傻傻的等) ； lock锁就不一定会等待下去；

5.Synchronized 可重入锁，不可以中断的，非公平； Lock，可重入锁，可以判断锁，非公平(可以自己设置)

6.Synchronized 适合锁少量的代码同步问题，lock锁适合锁大量的同步代码

4.生产者和消费者问题

面试常考点的：单例模式、排序算法、生产者和消费者、死锁

生产者和消费者问题 Synchronized 版

package com.jihu.productor;
/**
 * 线程之间的通信问题：生产者和消费者问题！  等待唤醒，通知唤醒
 * 线程交替执行  A   B 操作同一个变量   num = 0
 * A num+1
 * B num-1
 */
public class A {
    public static void main(String[] args) {
        Date date = new Date();

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

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

//可以将生产消费者模式分为 ( 判断等待，业务，通知 ) 三个步骤
class Date{ //数字  资源类
    private int number = 0;

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

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

if 改为 while 判断

就可以改变此问题的发生

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

通过Lock 找到 Condition

package com.jihu.productor;

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) {
        Date2 date = new Date2();

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

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

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

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

    }
}

//可以将生产消费者模式分为 ( 判断等待，业务，通知 ) 三个步骤
class Date2{ //数字  资源类
    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //+1
    public synchronized void  increment() throws InterruptedException {
       lock.lock(); //上锁
        try {
            while (number != 0){
                //等待
                condition.await(); //等待
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，我+1完毕了
            condition.signalAll(); //唤醒全部
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();  //解锁
        }


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

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

Condition 精准的通知和唤醒线程

package com.jihu.productor;

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 C {
    public static void main(String[] args) {
        Data3 data3 = new Data3();

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

    }
}

class Data3{ //资源类 lock
    private Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int number = 1; // 1时A执行，2 B执行，3 C执行

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

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

    }
    public void  printB(){
        lock.lock();
        try {
            while (number != 2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBBBB");
            //唤醒 ，唤醒指定的人，C
            number = 3;
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public void  printC(){
        lock.lock();
        try {
            while (number != 3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCCCCC");
            //唤醒 ，唤醒指定的人，A
            number = 1;
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

测试

5. 8锁现象

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

深刻理解我们的锁

测试1

package com.jihu.lock8;

import java.util.concurrent.TimeUnit;

/*
 8锁:就是关于锁的8个问题
 1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信  2/打电话
 2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信  2/打电话
 */
public class Test01 {
    public static void main(String[] args) {
        Phone phone = new Phone();

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

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

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

测试2

package com.jihu.lock8;

import java.util.concurrent.TimeUnit;
/*
    3. 增加了一个普通方法后  是先执行发短信还是hello?  答案是： 普通方法
    4. 两个对象，两个同步方法，发短信还是 打电话？  //打电话
 */
public class Test02 {
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁
        Phone2 phone = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{
            try {
                phone.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }
}
class Phone2{
    //synchronized 锁的对象是方法的调用者
    public synchronized void  sendSms() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("发短信");
    }
    public synchronized void  call(){
        System.out.println("打电话");
    }
    //这里没有锁，不是同步方法，不受锁的影响
    public  void  hello(){
        System.out.println("hello");
    }
}

测试3

package com.jihu.lock8;

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

        new Thread(()->{
            try {
                phone.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }
}
//Phone3唯一的一个Class对象
class Phone3{
    //synchronized 锁的对象是方法的调用者
    //static 静态方法
    //类一加载就有了  锁的是Class
    public static synchronized void  sendSms() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("发短信");
    }
    public static synchronized void  call(){
        System.out.println("打电话");
    }
}

//测试：
发短信
打电话

测试4

package com.jihu.lock8;

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

        new Thread(()->{
            try {
                phone.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }
}

class Phone4{
    //静态的同步方法，锁的是Class类模板
    public static synchronized void  sendSms() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("发短信");
    }
    //普通的同步方法  锁的调用者
    public  synchronized void  call(){
        System.out.println("打电话");
    }
}
//测试：
打电话
发短信

小结

new this 具体的一个手机

static Class 唯一的一个模板

6. 集合类不安全

List 不安全

package com.jihu.unsafe;

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

// java.util.ConcurrentModificationException 并发修改异常！
public class ListTest {
    public static void main(String[] args) {
        // 并发下 ArrayList 不安全的吗，Synchronized；
        /**
         * 解决方案：
         *  1.List<String> list = new Vector<>();
         *  2. List<String> list = Collections.synchronizedList(new ArrayList<>());
         *  3.List<String> list = new CopyOnWriteArrayList<>();
         */
        //CopyOnWrite 写入时复制，  COW 计算机程序设计领域的一种优化策略
        //多个线程调用的时候，list，读取的时候，固定的，写入(覆盖)
        //在写如的时候避免覆盖，造成数据问题
        //读写分离
        //CopyOnWriteArrayList比Vector NB在哪里？

//        List<String> list = new ArrayList<>(); //会出现ConcurrentModificationException 异常
//        List<String> list = new Vector<>();
//        List<String> list = Collections.synchronizedList(new ArrayList<>());
        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();
        }

    }


   /* public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "2", "3");
        list.forEach(System.out::println);
    }*/

}

Set 不安全

package com.jihu.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 SetTest {

    public static void main(String[] args) {
//        Set<String> set = new HashSet<>(); //会导入出现并发修改异常
//        Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set = new CopyOnWriteArraySet<>();

        for (int i = 0; i < 100; 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 set本质就是map  key是无法重复的
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

private static final Object PRESENT = new Object();  //不变的值

Map 不安全

回顾Map基本操作

package com.jihu.unsafe;

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

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

        //研究ConcurrentHashMap底层原理 在jdk帮助文档中查看
        Map<String, String> map = new ConcurrentHashMap<>();


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

    }
}

7.Callable(简单)

1、可以有返回值

2、可以抛出异常

3、方法不同，run()/ call()

package com.jihu.callable;

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

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // new Thread(new Runnable()).start();
        // new Thread(new FutureTask()).start();
        // new Thread(new FutureTask( Callable )).start();
        new Thread().start(); // 怎么启动Callable

        MyThread myThread = new MyThread();
        FutureTask<Integer> futureTask = new FutureTask<>(myThread); //适配类

        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start(); //就会出现一次call，因为结果会被缓存

        Integer o = futureTask.get(); //这个get 方法可能会产生阻塞，把他放到最后,或者使用异步通信来处理

        System.out.println(o);

    }
}
class MyThread implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("call");
        return 1024;
    }
}
//展示结果
call
1024

细节：

1、有缓存

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

8.常用的辅助类(必会)

8.1 CountDownLatch

//CountDownLatch   相当于减法计数器
package com.jihu.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
            },String.valueOf(i)).start();

        }

       countDownLatch.await();  //等待计数器归零， 然后再向下执行
        System.out.println("close door");
    }
}
//测试结果
0 go out
1 go out
4 go out
3 go out
5 go out
2 go out
close door

原理：

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

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

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

8.2 CyclicBarrier

//CyclicBarrier 想当于加法计数器
package com.jihu.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("集齐7颗龙珠，召唤神龙");
        });

        for (int i = 1; i <= 7; i++) {
            final int temp = i;  //在lambda中不能直接使用本地i，作用域不同，所以需要转为final类型
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集了"+temp+"颗龙珠");
                try {
                    cyclicBarrier.await(); //没收集7颗龙珠则等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();

        }
    }
}
//测试
Thread-5收集了6颗龙珠
Thread-1收集了2颗龙珠
Thread-3收集了4颗龙珠
Thread-6收集了7颗龙珠
Thread-4收集了5颗龙珠
Thread-2收集了3颗龙珠
Thread-0收集了1颗龙珠
集齐7颗龙珠，召唤神龙

8.3 Semaphore

Semaphore：信号量

抢车位！

6车---3个停车位置

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

原理：

semaphore.acquire() 获得，假设如果已经满了，等待，等待被释放为止！

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

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

9.读写锁

package com.jihu.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 myCache = new MyCache();
        MyCacheLock myCache = new MyCacheLock();

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

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

    //存，写入的时候，只希望同时只有一个线程写
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();//写加锁
        try {
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入OK");
        } catch (Exception exception) {
            exception.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock(); //写解锁
        }
    }
    //取 ，读时 所有人都可以读
    public void get(String key){
        readWriteLock.readLock().lock(); //读加锁
        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        } catch (Exception exception) {
            exception.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock(); //读解锁
        }
    }

}
//测试结果
   /*     4写入4
        4写入OK
        3写入3
        3写入OK
        0读取0
        0读取OK
        1读取1
        1读取OK*/

//自定义缓存
class  MyCache{
   private volatile Map<String,Object> map =  new HashMap<>();
  // 存，写
   public void put(String key,Object value){
       System.out.println(Thread.currentThread().getName()+"写入"+key);
       map.put(key,value);
       System.out.println(Thread.currentThread().getName()+"写入OK");
    }
    // 取，读
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取OK");
    }

}
//出现的问题
      /*  9写入9
        7读取7
        6写入6
        3写入3
        4读取4
        0读取0
        8读取8
        8写入8*/

10.阻塞队列

阻塞队列：

BlockingQueue BlockingQueue 不是新的东西

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

学会使用队列

添加、移除

四组API（重要）

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

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

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

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        
        System.out.println(blockingQueue.element()); //查看队首元素是谁

        //java.lang.IllegalStateException: Queue full 跑出异常
//        System.out.println(blockingQueue.add("d"));

        System.out.println("--------------");

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

    }

  /*
        有返回值，不抛出异常
     */
    public  static void  test2(){
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.offer("a2"));
        System.out.println(blockingQueue.offer("b2"));
        System.out.println(blockingQueue.offer("c2"));
        System.out.println(blockingQueue.peek());  //检查队首元素
        
        //blockingQueue.offer("d2")   返回false  不抛出异常
        System.out.println(blockingQueue.offer("d2"));

        System.out.println("--------------");
        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);

        blockingQueue.offer("a");
        blockingQueue.offer("b");
        blockingQueue.offer("c");
//        blockingQueue.offer("d",2, TimeUnit.SECONDS); //等待2秒 超时后就会退出
        System.out.println("------------");
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        blockingQueue.poll(2,TimeUnit.SECONDS); //等待超时2秒后就退出

    }

SynchronousQueue 同步队列

没有容量，

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

put、take

package com.jihu.bq;

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

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

       new Thread(()->{
           try {
               System.out.println(Thread.currentThread().getName()+" put 1");
               blockingQueue.put(1);
               System.out.println(Thread.currentThread().getName()+" put 2");
               blockingQueue.put(2);
               System.out.println(Thread.currentThread().getName()+" put 3");
               blockingQueue.put(3);
           } catch (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);
                System.out.println(Thread.currentThread().getName()+"=>"+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T2").start();
       

    }

}
//测试
T1 put 1
T1 put 2
T2=>1
T1 put 3
T2=>2
T2=>3

11. 线程池(重点)

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

池化技术

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

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

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

线程池的好处:

1、降低资源的消耗

2、提高响应的速度

3、方便管理。

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

1.三大方法

线程池：三大方法

package com.jihu.bq;

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 < 10; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        } finally {
            // 线程池用完，程序结束，关闭线程池
            threadPool.shutdown();
        }

    }

}

newSingleThreadExecutor测试结果：

newFixedThreadPool(5)测试结果：

newCachedThreadPool测试结果：

2、7大参数

7大参数

源码分析

public static ExecutorService newSingleThreadExecutor() {

    return new FinalizableDelegatedExecutorService

        (new ThreadPoolExecutor(1, 1,

                                0L, TimeUnit.MILLISECONDS,

                                new LinkedBlockingQueue()));

}

public static ExecutorService newFixedThreadPool(int nThreads) {

    return new ThreadPoolExecutor(5, 5,

                                  0L, TimeUnit.MILLISECONDS,

                                  new LinkedBlockingQueue());

}

public static ExecutorService newCachedThreadPool() {

    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                  60L, TimeUnit.SECONDS,

                                  new SynchronousQueue());
}


// 本质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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

手动创建一个线程池

package com.jihu.bq02;

import java.util.concurrent.*;

/**
 * new ThreadPoolExecutor.AbortPolicy()  //银行满了，还有人进来，不处理这个人的，抛出异常
 *  new ThreadPoolExecutor.CallerRunsPolicy()  //哪来的去哪里   main来的就main方法执行
 *  new ThreadPoolExecutor.DiscardPolicy()  //队列满了，丢掉任务，不会抛出异常
 * new ThreadPoolExecutor.DiscardOldestPolicy()  //队列满了，尝试去和最早的竞争，如果最早的快要结束了就可能等会，要不然就会离开，不会抛出异常
 */
public class Demo02 {
    public static void main(String[] args) {
        //自定义线程池！  工作工需要自己自定义
        ExecutorService threadPool =  new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());  //队列满了，尝试去和最早的竞争，如果最早的快要结束了就可能等会，要不然就会离开，不会抛出异常
        try {
            // 最大承载：Deque + max
            // 超过 最大承载后 抛出： java.util.concurrent.RejectedExecutionException
            for (int i = 0; i < 9; i++) {
                // 使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();// 线程池用完，程序结束，关闭线程池
        }
    }

}

3、四种拒绝策略

四种拒绝策略

/**
 * new ThreadPoolExecutor.AbortPolicy()  //银行满了，还有人进来，不处理这个人的，抛出异常
 *  new ThreadPoolExecutor.CallerRunsPolicy()  //哪来的去哪里   main来的就main方法执行
 *  new ThreadPoolExecutor.DiscardPolicy()  //队列满了，丢掉任务，不会抛出异常
 * new ThreadPoolExecutor.DiscardOldestPolicy()  //队列满了，尝试去和最早的竞争，如果最早的快要结束了就可能等会，要不然就会离开，不会抛出异常
 */

小结和拓展

池的最大的大小如何去设置！（下面代码即是）

了解：IO密集型，CPU密集型：（调优用到的）

package com.jihu.bq02;

import java.util.concurrent.*;

public class Demo02 {
    public static void main(String[] args) {
        //自定义线程池！  工作工需要自己自定义

        // 最大线程到底该如何定义
        // 1、CPU 密集型，几核，就是几，可以保持CPU的效率最高！
        // 2、IO  密集型   > 判断你程序中十分耗IO的线程，
        // 程序   15个大型任务  IO十分占用资源！(io密集型要定义大于15才行，才有其他的线程去执行别的任务)

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

        ExecutorService threadPool =  new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());  //队列满了，尝试去和最早的竞争，如果最早的快要结束了就可能等会，要不然就会离开，不会抛出异常
        try {
            // 最大承载：Deque + max
            // 超过 最大承载后 抛出： java.util.concurrent.RejectedExecutionException
            for (int i = 0; i < 9; i++) {
                // 使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();// 线程池用完，程序结束，关闭线程池
        }
    }

}

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

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

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

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

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

Function函数式接口

代码测试

package com.jihu.function;

import java.util.function.Function;
/*
 * Function 函数型接口, 有一个输入参数，有一个输出
 * 只要是 函数型接口 可以 用 lambda表达式简化
 */
public class Demofunction01 {
    public static void main(String[] args) {
//        Function<String, String> function = new Function<>(){
//
//            @Override
//            public String apply(String str) {
//                return str;
//            }
//        };
        //（str） 为传入的参数
        //{return str;}  里面为具体的代码
        Function<String, String> function =(str)->{return str;}; //lambada表达式对上面式子的简化
        System.out.println(function.apply("aaa1"));
    }
}

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

package com.jihu.function;

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

        Predicate<String> predicate =(str)->{return  str.isEmpty();};
        System.out.println(predicate.test("1as")); //返回false
//        System.out.println(predicate.test("")); //返回true

    }
}

Consumer 消费型接口

package com.jihu.function;

import java.util.function.Consumer;
/**

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

        Consumer<String> consumer =(str)->{
            System.out.println(str);
        };
        consumer.accept("asad");

    }
}

Supplier 供给型接口

package com.jihu.function;

import java.util.function.Supplier;
/**
 * Supplier 供给型接口 没有参数，只有返回值
 */
public class Demofunction04 {
    public static void main(String[] args) {
        /*Supplier<String> supplier = new Supplier<>(){
            @Override
            public String get() {
                return "stras";
            }
        };*/

        Supplier<String> supplier =()->{return "adas";};
        System.out.println(supplier.get());

    }
}

13、Stream流式运算

什么是Stream流式运算

大数据：存储 + 计算

集合、MySQL 本质就是存储东西的；

计算都应该交给流来操作！

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

package com.jihu.stream;

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

/**
 * 题目要求：一分钟内完成此题，只能用一行代码实现！
 * 现在有5个用户！筛选：
 * 1、ID 必须是偶数
 * 2、年龄必须大于23岁
 * 3、用户名转为大写字母
 * 4、用户名字母倒着排序
 * 5、只输出一个用户！
 */
public class Trst {
    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);
        //集合就是存储   把上述user存入集合中
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5,u6);

        //计算交给stream流
        // lambda表达式、下面叫 链式编程、函数式接口、Stream流式计算
        list.stream()
                .filter(u->{return  u.getId()%2==0;})  //ID 必须是偶数
                .filter(u->{return  u.getAge()>23;})  //年龄必须大于23岁
                .map(u->{return  u.getName().toUpperCase();})   //用户名转为大写字母   D F
                .sorted((uu1,uu2)->{return  uu2.compareTo(uu1);})  //   用户名字母倒着排序   F D
                .limit(1)   //  只输出一个用户！  F 
                .forEach(System.out::println);
        
    }

}

14、ForkJoin

什么是 ForkJoin

ForkJoin 在 JDK 1.7 ，并行执行任务！提高效率。大数据量 才使用它！

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

ForkJoin 特点：工作窃取

这个里面维护的都是双端队列(B执行完后开始执行A的任务，这叫工作窃取，但可能会出现同时都抢一个资源的现象。)

ForkJoin

package com.jihu.forkjoin;

import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

/**
 * 求和计算的任务！
 * 3000   6000（ForkJoin）  9000（Stream并行流）
 * // 如何使用 forkjoin
 * // 1、forkjoinPool 通过它来执行
 * // 2、计算任务 forkjoinPool.execute(ForkJoinTask 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 = (end+start)/2;  //中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork(); //拆分任务，把任务压入线程队列

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

        }
    }
}

测试

package com.jihu.forkjoin;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        test1(); //11583
//        test2();   //9751
        test3(); //899
    }
    // 普通程序员
    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 task = new ForkJoinDemo(0L,10_0000_0000L);
        ForkJoinTask submit = forkJoinPool.submit(task); //提交任务
        Long sum = (Long) submit.get();

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

    public static void test3(){

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

}

15、异步回调

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

package com.jihu.future;

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

/**
 * 异步调用： CompletableFuture
 * // 异步执行
 * // 成功回调
 * // 失败回调
 */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //没有返回值的 runAsync 异步回调
        //Void跟void不同，Void是包装类，和Integer类似
      /*  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(); // 获取阻塞执行结果     */
        
        //输出结果为
//        1111
//        ForkJoinPool.commonPool-worker-3runAsync=>Void


        //有返回值的  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); //错误信息 :java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        }).exceptionally((e)->{
            System.out.println(e.getMessage());
            return 233; // 可以获取到错误的返回结果
        }).get());

        //输出结果为 正常的话
        /*ForkJoinPool.commonPool-worker-3supplyAsync => Integer
        t=>1024
        u=>null
        1024*/

        //输出结果为 不正常的话
        /*ForkJoinPool.commonPool-worker-3supplyAsync => Integer
        t=>null
        u=>java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        java.lang.ArithmeticException: / by zero
        233*/
    }

}

16、JMM

请你谈谈你对 Volatile 的理解

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

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是JMM

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

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

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

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

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

线程 工作内存、主内存

8种操作：

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

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

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

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

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

17、Volatile

1.保证可见性

1、保证可见性

package com.jihu.volatilet;

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 (num==0){

            }
        }).start();

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

    }

}

//输出结果
1

2.不保证原子性

2、不保证原子性

package com.jihu.volatilet;

public class VDemo02 {
    // volatile 不保证原子性
    private volatile static int num = 0;

    public  static void add(){
        num++;
    }

    public static void main(String[] args) {
        //理论上num结果应该为 2 万
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int i1 = 0; i1 < 1000; i1++) {
                    add();
                }
            }).start();
        }

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

}

//输出结果
main 16599

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

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

package com.jihu.volatilet;

import java.util.concurrent.atomic.AtomicInteger;

public class VDemo02 {
    // volatile 不保证原子性
//    private volatile static int num = 0;
     // 原子类的 Integer
    private static AtomicInteger num= new AtomicInteger();
    public  static void add(){
//        num++;  // 不是一个原子性操作
        num.getAndIncrement();  // AtomicInteger + 1 方法， CAS
    }

    public static void main(String[] args) {
        //理论上num结果应该为 2 万
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int i1 = 0; i1 < 1000; i1++) {
                    add();
                }
            }).start();
        }

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

}
//输出结果
main 20000

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

3.指令重排

3.指令重排

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

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

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

int x = 1; // 1
int y = 2; // 2
x = x + 5; // 3
y = x * x; // 4
我们所期望的：1234 但是可能执行的时候回变成 2134 1324
可不可能是 4123

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

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

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

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

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

非计算机专业

volatile可以避免指令重排：

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

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

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

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

18、彻底玩转单例模式

饿汉式 DCL懒汉式，深究！

19、深入理解CAS

20、原子引用

21、各种锁的理解

posted @ 2022-05-01 16:49 爲誰心殇阅读(95) 评论(0) 编辑收藏举报

刷新页面返回顶部

爲誰心殇

JUC由简入深学习

JUC学习

1.什么是JUC

2.线程和进程

3.Lock锁(重点)

4.生产者和消费者问题

5. 8锁现象

6. 集合类不安全

7.Callable(简单)

8.常用的辅助类(必会)

8.1 CountDownLatch

8.2 CyclicBarrier

8.3 Semaphore

9.读写锁

10.阻塞队列

四组API（重要）

11. 线程池(重点)

1.三大方法

2、7大参数

3、四种拒绝策略

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

13、Stream流式运算

14、ForkJoin

15、异步回调

16、JMM

17、Volatile

1.保证可见性

2.不保证原子性

3.指令重排

18、彻底玩转单例模式

19、深入理解CAS

20、原子引用

21、各种锁的理解

公告