JUC重点详解

一、前瞻

1、什么是JUC

java.util.concurrent包

2、线程与进程

一个进程往往包含多个线程
java默认有两个线程：main、GC(垃圾回收)
java真的可以开启线程吗？
不可以，底层使用C++，java无法直接操作硬件

1>线程六大状态

        //新生
        NEW,

        //运行
        RUNNABLE,

        //阻塞
        BLOCKED,
        //等待
        WAITING,

        //等待超时
        TIMED_WAITING,

        //终止
        TERMINATED;

2>wait和sleep的区别

1、来自不同的类
wait–>Object
sleep–>Thread
2、wait会释放锁，sleep不会释放锁
3、使用范围不同
wait必须在同步代码块中使用
sleep可以在任何地方使用

3、并发与并行

并发即多线程操作同一个资源
单核CPU快速交替
并行即多个线程同时执行；线程池
并发变成的本质：充分利用CPU资源

二、Lock

1、传统的synchronized

package cn.biliball;

public class Test01 {
    public static void main(String[] args) {
        //获取CPU核数
        //System.out.println(Runtime.getRuntime().availableProcessors());
        
        final Ticket ticket=new Ticket();

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

    }
}
//资源类
class Ticket{
    private int number=30;
    public synchronized void sale(){
        if(number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票，剩余"+number+"张票。");
        }
    }
}

2、使用Lock

Lock的三个实现类
ReentrantLock()（重入锁）
ReentrantReadWriteLock.ReadLock()（读锁）
ReentrantReadWriteLock.WriteLock()（写锁）

公平锁：先来先执行
非公平锁：可以插队
java默认非公平锁，保证CPU利用率

package cn.biliball;

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

public class Test02 {

    public static void main(String[] args) {
        //获取CPU核数
        //System.out.println(Runtime.getRuntime().availableProcessors());

        final Ticket02 ticket=new Ticket02();

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

    }
}
//资源类
class Ticket02{
    private int number=30;

    Lock lock=new ReentrantLock();
    public void sale(){

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

3、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、生产者和消费者问题

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

package cn.biliball.pc;

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

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

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

    //-1
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) { // 1
            //问题存在，A B C D 4 个线程！ 虚假唤醒
            //if 改为 while 判断
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

如果有四个线程，会存在虚假唤醒的问题

将if换成while

5、JUC版的生产者与消费者问题

package cn.biliball.pc;

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

public class B {

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

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

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

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

    Lock lock = new ReentrantLock();

    Condition condition = lock.newCondition();

    //+1
    public void increment() throws InterruptedException {
        lock.lock();

        try {
            while (number != 0) { //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) { // 1
                //问题存在，A B C D 4 个线程！ 虚假唤醒
                //if 改为 while 判断
                // 等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 通知其他线程，我-1完毕了
            condition.signalAll();

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

    }
}

问题：状态随机（希望ABCD有序执行，A执行完唤醒B，B执行完唤醒C，C执行完唤醒D，D执行完唤醒A）
使用Condition（同步监视器）
Condition：精准的唤醒和通知线程
使用多个同步监视器实现：

package cn.biliball.pc;

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

public class C {

    public static void main(String[] args) {
        Data03 data = new Data03();
        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 Data03 { // 数字 资源类
    private int number = 1;//1->a,2->b,3->c

    Lock lock = new ReentrantLock();

    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    public void printA() {
        lock.lock();
        try {
            while (number != 1) { //0
                // 等待
                condition1.await();
            }
            number = 2;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 通知其他线程，我+1完毕了
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void printB() {
        lock.lock();
        try {
            while (number != 2) { //0
                // 等待
                condition2.await();
            }
            number=3;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 通知其他线程，我+1完毕了
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void printC() {
        lock.lock();
        try {
            while (number != 3) { //0
                // 等待
                condition3.await();
            }
            number=1;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 通知其他线程，我+1完毕了
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

5、八锁

package cn.biliball.locks;

import java.util.concurrent.TimeUnit;

/*
*八锁，关于锁的八个问题
* 1、标准情况下，两个线程打印 发短信还是打电话？ 先发短信后打电话
* 2、sendSms延迟4秒后，两个线程先打印发短信还是打电话？先发短信后打电话
* */
public class Ques01 {
    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(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

package cn.biliball.locks;

import java.util.concurrent.TimeUnit;

/*
* 3、增加一个普通方法后，先执行hello还是发短信，先hello后发短信
* 4、增加Phone2，变成两个对象
*/
public class Ques02 {

    public static void main(String[] args) {
        //两个不同的对象，两把锁
        Phone02 phone=new Phone02();
        Phone02 phone2=new Phone02();
        //两个方法使用的同一个锁，谁先拿到谁先执行
        new Thread(()->{
            phone.sendSms();
        },"A").start();

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

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

    }
}

class Phone02{
    //synchronized 锁的对象是方法的调用者

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    //不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

package cn.biliball.locks;

import java.util.concurrent.TimeUnit;

/*
* 5、增加两个静态的同步方法,只有一个对象
* 6、两个对象，增加两个静态的同步方法
* */
public class Ques03 {

    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static锁的是class
        Phone03 phone=new Phone03();
        Phone03 phone2=new Phone03();
        //两个方法使用的同一个锁，谁先拿到谁先执行
        new Thread(()->{
            phone.sendSms();
        },"A").start();

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

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

    }
}

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

package cn.biliball.locks;

import java.util.concurrent.TimeUnit;

/*
* 7、一个静态方法，一个普通方法，一个对象
* 8、一个静态方法，一个普通方法，两个对象
* */
public class Ques04 {

    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static锁的是class
        Phone04 phone = new Phone04();
        //两个方法使用的同一个锁，谁先拿到谁先执行
        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

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

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

    }
}

class Phone04 {
    //静态同步方法
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通同步方法
    public synchronized void call() {
        System.out.println("打电话");
    }
}

小结

new this，锁的是这个对象
static 锁的是Class模板（唯一的）

6、集合类不安全

List不安全

package cn.biliball.unsafe;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import org.w3c.dom.ls.LSOutput;

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

public class ListTest {

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

        //CopyOnWrite 写入时复制  COW 计算机程序设计领域的一种优化策略
        //多个线程调用的时候，list，读取的时候，固定的写入（覆盖）
        //在写入的时候避免覆盖，造成数据问题
        //读写分离思想
        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("线程："+Thread.currentThread().getName()+":"+list);
            },String.valueOf(i)).start();
        }
    }

}

问题？？
为什么用CopyOnWriteArrayList不用Vector？？
加synchronized会使效率变低

set不安全

package cn.biliball.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 set = Collections.synchronizedSet(new HashSet<>());//通过工具类转换成synchronized
 * 2、Set set= new CopyOnWriteArraySet<>();//写入时复制，保证效率
 * */
public class SetTest {
    public static void main(String[] args) {
        // Set set=new HashSet<>();
       // Set set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set= new CopyOnWriteArraySet<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(set);
            }, String.valueOf(i)).start();

        }
    }
}

HashSet底层是？？

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

HashMap

package cn.biliball.unsafe;

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

/*
* 1、Map map= Collections.synchronizedMap(new HashMap<>());
* 2、Map map=new ConcurrentHashMap<>();  //并发的HashMap
* */
public class MapTest {
    public static void main(String[] args) {
        //map是这样用的吗？不是，工作中不用HashMap
        //默认等价于什么  new HashMap<>(16,0。75);默认初始化容量=16、加载因子=0.75

      //  Map map=new HashMap<>();
        //Map map= Collections.synchronizedMap(new HashMap<>());
        Map<String,String> map=new ConcurrentHashMap<>();


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

    }
}

7、Callable

官方解释：Callable接口类似于Runnable，因为它们都是为其实例可能由另一个线程执行的类设计的。然而，Runnable不返回结果，也不能抛出异常。
1、可以有返回值
2、可以抛出异常
3、方法不同，run()、call()

泛型的参数等于方法的返回值

代码测试

package cn.biliball.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 {
        //Thread只能接收Runnable
        //new Thread(new Runnable()).start();等同于new Thread(new FutureTask())).start();
        //new Thread(new FutureTask())).start();等同于new Thread(new FutureTask(Callable))).start();
        //new Thread().start();怎么启动Callable
        MyThread thread=new MyThread();
        FutureTask futureTask=new FutureTask(thread);
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();//结果会被缓存，效率高
        String o = (String)futureTask.get();//获取Callable返回结果，这个get()可能会发生阻塞
        System.out.println(o);
    }
}
class MyThread implements Callable<String> {


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

注：
1、结果可能等待，因为可能会发生阻塞。解决方法：异步通信
2、缓存，提高效率

8、常用的辅助类

8.1、CountDownLatch（减法计数器）

官方解释：允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

代码

package cn.biliball.add;


import java.util.concurrent.CountDownLatch;

//计数器
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        //总数为6
        CountDownLatch countDownLatch=new CountDownLatch(6);
        for(int i=0;i<countDownLatch.getCount();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()就会被唤醒，继续执行。

8.2、CyclicBarrier（加法计数器）

package cn.biliball.add;

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

public class CyclicBarrierTest {

    public static void main(String[] args) throws InterruptedException {
        //总数为6
        //计数达到后，会开启一个新的线程
        CyclicBarrier cyclicBarrier=new CyclicBarrier(6,()->{
            System.out.println("总数为6");
        });
        for (int i=0;i<6;i++){
            final int temp=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"：第"+temp+"个");
                try {
                    cyclicBarrier.await();//等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

8.3、Semaphore（信号量）

定义：一个计数信号量、在概念上、信号量维持一组许可证、如果有必要，每个acquire()都会阻塞，直到许可证可用，然后才能使用它。（相当于通行证）
类似抢车位

package cn.biliball.add;

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

public class SemaphoreTest {
    public static void main(String[] args) {
        //线程数量（3个车位）
        Semaphore semaphore=new Semaphore(3);
        for (int i=0;i<6;i++){
            new Thread(()->{
                // acquire()得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println(Thread.currentThread().getName()+"离开车位");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                finally {
                    semaphore.release();// release()释放
                }
            },String.valueOf(i)).start();
        }
    }
}

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

9、ReadWriteLock(读写锁)

ReadWriteLock：读可以被多线程同时读，写的时候只能有一个线程去写

代码

package cn.biliball.rw;

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

/*
独占锁（写锁）一次只能被一个线程占有
共享锁（读锁）多个线程可以同时占有
* ReadWriteLock
* 读-读  可以共存
* 读-写  不能共存
* 写-写  不能共存
* */
public class ReadWriteLockTest {
    public static void main(String[] args) {

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

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


    }
}

//加锁
class MyCacheLock{
    private volatile Map<String,Object> map=new HashMap<>();

    //读写锁：更加细粒度的控制
    private 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()+"写入完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }

    }

    //读
    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o=map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }

    }
}

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

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

    //取
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o=map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取完成");
    }
}

10、阻塞队列.

BlockingQueue:阻塞队列

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

代码

package cn.biliball.bq;

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

public class BlockingQueueTest {

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

    //抛出异常，有返回值
    public static void test1(){
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(arrayBlockingQueue.add("a"));
        System.out.println(arrayBlockingQueue.add("b"));
        System.out.println(arrayBlockingQueue.add("c"));

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

        System.out.println("===================");
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());

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

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

        System.out.println(arrayBlockingQueue.offer("d"));//返回false 不抛出异常

        System.out.println("===================");
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());

        System.out.println(arrayBlockingQueue.poll());//返回null，不抛出异常
    }

    //等待，阻塞（一直阻塞）
    public static void test3() throws InterruptedException {
        ArrayBlockingQueue arrayBlockingQueue=new ArrayBlockingQueue<>(3);

        //一直阻塞
        arrayBlockingQueue.put("a");
        arrayBlockingQueue.put("b");
        arrayBlockingQueue.put("c");
        //arrayBlockingQueue.put("d");//队列没有位置，一直阻塞

        //拿
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());//没有这个元素
    }

    //超时等待
    public static void test4() throws InterruptedException {
        ArrayBlockingQueue arrayBlockingQueue=new ArrayBlockingQueue<>(3);

        //超时等待
        System.out.println(arrayBlockingQueue.offer("a"));
        System.out.println(arrayBlockingQueue.offer("b"));
        System.out.println(arrayBlockingQueue.offer("c"));
        System.out.println(arrayBlockingQueue.offer("d", 5, TimeUnit.SECONDS));//超时退出

        System.out.println("移除元素"+arrayBlockingQueue.poll());
        System.out.println("队首元素："+arrayBlockingQueue.peek());//输出队首元素
        System.out.println("移除元素"+arrayBlockingQueue.poll());
        System.out.println("队首元素："+arrayBlockingQueue.peek());//输出队首元素
        System.out.println("移除元素"+arrayBlockingQueue.poll());
        arrayBlockingQueue.poll(5, TimeUnit.SECONDS);//超时退出
    }
}

SynchronousQueue同步队列

没有容量
进去一个元素，必须等待取出来之后，才能往里面放一个元素

package cn.biliball.bq;

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

/*
* 同步队列
* SynchronousQueue不存储元素
* put了一个元素，必须从里面先take取出来，否则不能在put进去只
* */
public class SynchronousQueueTest {
    public static void main(String[] args) {
        BlockingQueue<String> 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();
            }
        },"A").start();

        new Thread(()->{

            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"取"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"取"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"取"+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}

11、线程池

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

池化技术

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

线程池的好处：

1、降低资源消耗

2、提高响应速度

3、方便管理

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

线程池三大方法：
1、newSingleThreadExecutor() //单个线程
2、newFixedThreadPool(5) //固定大小
3、newCachedThreadPool() //可变大小

package cn.biliball.pool;

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

/*
* Executors 工具类，3大方法
* 1、newSingleThreadExecutor()  //单个线程
* 2、newFixedThreadPool(5)   //固定大小
* 3、newCachedThreadPool()   //可变大小
* */
public class Test01 {
    public static void main(String[] args) {
        //ExecutorService executorService = Executors.newSingleThreadExecutor();//单个线程
        //ExecutorService executorService = Executors.newFixedThreadPool(5);//创建一个固定的线程池大小
        ExecutorService executorService = Executors.newCachedThreadPool();//可伸缩的

        try {
            for(int i=0;i<10;i++){
                //使用线程池来创建线程
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"  OK");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            executorService.shutdown();
        }


    }
}

手动创建线程池：

package cn.biliball.pool;


import java.util.concurrent.*;

/*
* 手动创建
* */
public class Test02 {

    public static void main(String[] args) {

        //自定义线程池
        ExecutorService threadPool=new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());//拒绝策略（不处理，抛出异常）
        try {
            //最大承载：队列+最大核心线程池大小
            //超出最大承载，抛出异常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();
        }


    }
}

七大参数
int corePoolSize //核心线程池大小
int maximumPoolSize //最大核心线程池大小
long keepAliveTime //超时了没有人调用就会释放
TimeUnit unit //超时单位
BlockingQueue workQueue //阻塞队列
ThreadFactory threadFactory //线程工厂，创建线程的，一般不用动
RejectedExecurionHandler handle //拒绝策略

    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;
    }

四大拒绝策略
1、AbortPolicy //不处理，抛出异常
2、CallerRunsPolicy //哪来的去哪里
3、DiscardOldestPolicy //队列满了，尝试去和最早的竞争，不抛出异常
4、DiscardPolicy // 队列满了，丢掉任务，不会抛出异常

小结和拓展
最大线程池到底该如何定义
1、CPU 密集型 几核就是几，可以保持CPU的效率最高
//Runtime.getRuntime().availableProcessors();//获取CPU核数
2、IO 密集型 。判断你的程序中十分耗IO的线程，（一般设置其两倍大小）
//程序 10个大型任务，IO十分占用资源！！

12、四大函数试接口（重点）

新时代必须掌握：lambda表达式、链式编程、函数式接口、Stream流试计算
函数式接口：只有一个方法的接口
@FunctionalInterface
底层大量使用函数式接口

①、Function函数式接口

传入一个参数， 输出一个参数

package cn.biliball.function;

import java.util.function.Function;

/*
* Function函数型接口，有一个输入参数，一个输出参数
* 只要是 函数型接口，可以用lambda表达式简化
* */
public class Test01 {
    public static void main(String[] args) {
//        Function function=new Function() {
//            @Override
//            public String apply(String s) {
//                return s+"123";
//            }
//        };

        Function<String,String> function=(s)->{return s+"123";};

        System.out.println(function.apply("asd"));
    }
}

②、Predicate断定性接口

传入一个参数，输出boolean类型

package cn.biliball.function;

import java.util.function.Predicate;
/*
* 断定型接口，有一个输入参数，返回值只能是布尔值
* */
public class Test02 {
    public static void main(String[] args) {
//        Predicate predicate=new Predicate() {
//            //例如可以是一个判断字符串是否为空
//            @Override
//            public boolean test(String s) {
//                if(s==null||s.isEmpty()){
//                    return true;
//                }
//                else return false;
//            }
//        };

        Predicate<String> predicate = (s) -> {
            if (s == null || s.isEmpty()) {
                return true;
            } else return false;
        };

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

③、Consumer消费型接口

只有输入，没有返回值

package cn.biliball.function;

import java.util.function.Consumer;

public class Test03 {
    public static void main(String[] args) {
//        Consumer consumer=new Consumer() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        };
        Consumer<String> consumer=(s)->{
            System.out.println(s);
        };
        consumer.accept("sdf");
    }
}

④、Supplier供给型接口

没有参数，只有返回值

package cn.biliball.function;

import java.util.function.Supplier;

public class Test04 {
    public static void main(String[] args) {
//        Supplier supplier= new Supplier() {
//            @Override
//            public String get() {
//                return "get";
//            }
//        };
        Supplier<String> supplier=()->{
            return "get";
        };
        System.out.println(supplier.get());
    }
}

13、Stream流式计算

package cn.biliball.stream;

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

/*
* 题目要求：一分钟内完成此题，只能用一行代码实现
* 现在有五个用户！筛选，
* 1、ID必须是偶数
* 2、年龄必须大于23岁
* 3、用户名转为大写字母
* 4、用户名字母倒着排序
* 5、只输出一个用户
* */
public class Test01 {
    public static void main(String[] args) {
        User u1=new User(1,"a",22);
        User u2=new User(2,"b",26);
        User u3=new User(3,"c",18);
        User u4=new User(4,"d",25);
        User u5=new User(5,"e",21);

        //集合就是存储
        List<User> list= Arrays.asList(u1,u2,u3,u4,u5);
        //计算交给Stream流
        //lambda表达式，链式编程，函数式接口，Stream流式计算
        list.stream()
                .filter(u->{return u.getUserid()%2==0;})
                .filter(u->{return u.getAge()>23;})
        .map(u->{u.setName(u.getName().toUpperCase());return u;})
        .sorted((uu1,uu2)->{return uu2.getName().compareTo(uu1.getName());})
        .limit(1)
        .forEach(System.out::println);


    }
}

14、ForkJoin

并行执行任务，提高效率。

ForkJoin 特点：工作窃取
里面都是双端队列
B线程执行完后，帮A线程执行

15、异步回调

package cn.biliball.future;

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

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

        //没有返回值runAsync异步回调

//        CompletableFuture 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();//获取阻塞执行结果

        // 有返回值的 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());
/**
 * succee Code 200
 * error Code 404 500
 */
    }
}

16、JMM

谈谈你对Volatile的理解

1、保证可见性
2、不保证原子性
3、禁止指令重排

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

关于JMM的一些同步的约定
1、线程解锁前，必须把共享变量立刻刷回主存
2、线程加锁前，必须读取主存中的最新值到工作内存中！
3、加锁和解锁是同一把锁