JUC 并发编程

最新推荐文章于 2023-06-21 00:04:45 发布

James Cheung

最新推荐文章于 2023-06-21 00:04:45 发布

阅读量169

点赞数 1

文章标签： java juc lock 线程池 forkjoin

本文链接：https://blog.csdn.net/weixin_43053532/article/details/115356151

版权

JUC并发编程

1、什么是JUC

java.util工具包、包、分类

业务：普通的线程代码 Thread

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

2、线程和进程回顾

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

进程是操作系统调用的最小单位，线程是CPU调度的最小单位

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

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

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

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

对于Java而言：Thread、Runnable、Callable

Java真的可以开启线程吗

public synchronized void start() {
	boolean success = false;
	
	 
	try {
		synchronized(lock) {
			if (started) {
				// K0341 = Thread is already started
				throw new IllegalThreadStateException(com.ibm.oti.util.Msg.getString("K0341")); //$NON-NLS-1$
			}
 		
			group.add(this);
		
			startImpl();
 		 	
			success = true;
		}
 	} finally {
 		if (!success && !started) {
 	 		group.remove(this);
 		}
 	}
}
//本地方法，底层的C++，Java无法直接操作硬件
private native void startImpl();

并发、并行

并发编程：并发、并行

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

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

并行（多个人一起行走）

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

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

        //获取CPU的核数
        //CPU密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

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

所有的公司都很看重！

企业，挣钱=>提高效率，裁员，找一个厉害的人顶替三个不怎么样的人

人员（减）、技术成本（高）

线程有几个状态

// The order of the States is known by the getStateImpl() native 
public static enum State {
	/**
	 * A Thread which has not yet started.新生状态
	 */
	NEW,
	/**
	 * A Thread which is running or suspended.运行
	 */
	RUNNABLE,
	/**
	 * A Thread which is blocked on a monitor.阻塞
	 */
	BLOCKED, 
	/**
	 * A Thread which is waiting with no timeout.等待
	 */
	WAITING,
	/**
	 * A Thread which is waiting with a timeout.超时等待
	 */
	TIMED_WAITING, 
	/**
	 * A thread which is no longer alive.终止
	 */
	TERMINATED }

wait/sleep区别

1. 来自不同的类

wait => Object

sleep => Thread

2. 关于锁的释放

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

3. 使用的范围不同

wait 必须在同步代码块中

sleep 可以在任何地方睡

4. 是否需要捕获异常

wait不需要捕获异常

sleep需要捕获异常

3、Lock锁（重点）

传统Synchronized

/**
 *  真正的多线程开发，公司中的开发，降低耦合性
 *  线程就是一个单独的资源类，没有任何的附属操作！
 *  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 = 30;

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

lock 接口

Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition

Lock l = ...; 
l.lock(); //加锁
try { 
  // access the resource protected by this lock 
} finally { 
  l.unlock();//解锁
}

Interface Lock

所有已知实现类：
- ReentrantLock 可重入锁
- ReentrantReadWriteLock.ReadLock 读锁
- ReentrantReadWriteLock.WriteLock 写锁

    /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();	//非公平锁
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

公平锁FairSync()：十分公平，先来后到

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

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();

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

    }
}
//Lock
//1、new ReentrantLock()
//2、lock.Lock() 加锁
//3、lock.Unlock() 解锁
class Ticket2{
    //属性、方法
    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();
        }

    }

}

Synchronized 和 Lock区别

Synchronized 内置的java关键字，Lock是一个java类
Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁
Synchronized 会自动释放锁，lock 必须要手动释放锁！如果不释放锁，死锁
Synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock 锁不一定会等待下去
Synchronized 可重入锁，不可以中断，非公平；Lock，可重入锁，可以判断锁，非公平（可设置）
Synchronized 适合锁少量的代码同步问题。Lock 适合锁大量的同步代码

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

4、生产者和消费者问题

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

Synchronized版 wait notify

/**
 * 线程之间的通信问题：生产者消费者问题   等待唤醒、通知唤醒
 * 线程交替执行 A B 操作同一个变量 num = 0
 * A num+1
 * B num-1
 *
 */
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){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，+1完毕
        this.notifyAll();
    }

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

}

问题存在 A B C D 4个线程，则出现虚假唤醒，产品数量为负数情况

官方文档：线程也可以唤醒，而不会被通知，中断或超时，即所谓的虚假唤醒 。虽然这在实践中很少会发生，但应用程序必须通过测试应该使线程被唤醒的条件来防范，并且如果条件不满足则继续等待。换句话说，等待应该总是出现在循环中，就像这样：

  synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout);
         ... // Perform action appropriate to condition
     }

解决方法：if 改为 while 判断，每次循环结束都再去判断一下条件

一个消费者线程抢到执行权，发现product是0，就等待，这个时候，另一个消费者又抢到了执行权，product是0，还是等待，此时两个消费者线程在同一处等待。然后当生产者生产了一个product后，就会同时唤醒两个消费者，这两个消费者发现product是1，就会同时消费，结果就出现了0和-1。

JUC版的生产者消费者问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eOqqdUJS-1617183378555)(/Users/james/Library/Application Support/typora-user-images/截屏2021-03-25 下午5.40.34.png)]

通过Lock找到Condition，Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用

 class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock(); try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally { lock.unlock(); }
   }

   public Object take() throws InterruptedException {
     lock.lock(); try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally { lock.unlock(); }
   }
 }

代码实现：

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

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

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

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

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

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

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

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

//A 执行完调用B，B执行完调用C，C执行完调用A
public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();

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

//资源类 Lock
class Data3{
        private Lock lock = new ReentrantLock();
        private Condition condition1 = lock.newCondition();
        private Condition condition2 = lock.newCondition();
        private Condition condition3 = lock.newCondition();
        private int number = 1;

        public  void printA(){
            lock.lock();
            try {
                //业务、判断、执行、通知
                while (number!=1){
                    condition1.await();
                }
                System.out.println(Thread.currentThread().getName()+"->A");
                number = 2;
                condition2.signal();

            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
        public  void printB(){
            lock.lock();
            try {
                //业务、判断、执行、通知
                while (number!=2){
                    condition2.await();
                }
                System.out.println(Thread.currentThread().getName()+"->B");
                number = 3;
                condition3.signal();

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

        }
        public  void printC(){
            lock.lock();
            try {
                //业务、判断、执行、通知
                while (number!=3){
                    condition3.await();
                }
                System.out.println(Thread.currentThread().getName()+"->C");
                number = 1;
                condition1.signal();

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

5、8锁现象

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

深刻理解我们的锁

/**
 * 关于锁的8个问题
 * 1、标准情况下，两个线程先打印 发短信还是 打电话？   先发短信再打电话
 * 2、sendMsg延迟4秒，两个线程先打印 发短信还是 打电话？   等待4秒，先发短信再打电话
 */
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendMsg();
        },"A").start();

        TimeUnit.SECONDS.sleep(1);

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

class Phone{

    //synchronized 锁的对象是方法的调用者！
    //两个方法用的同一个锁，谁先拿到谁执行！
    public synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendMsg");
    }
    public synchronized void call(){
        System.out.println("call");
    }
}

/**
 * 3、增加了一个普通方法！发短信还是Hello？  普通方法hello
 * 4、两个对象，两个同步方法
 */
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        //两个对象，两个调用者，两把锁
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{
             phone1.sendMsg();
        },"A").start();

        TimeUnit.SECONDS.sleep(1);

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

class Phone2{

    //synchronized 锁的对象是方法的调用者！
    //两个方法用的同一个锁，谁先拿到谁执行！
    public synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendMsg");
    }
    public synchronized void call(){
        System.out.println("call");
    }
    //这里没有锁！不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

/**
 * 5、增加两个静态的同步方法，只有一个对象，先打电话还是发短信？  发短信
 * 6、两个对象！增加两个静态的同步方法，先打电话还是发短信？    发短信
 */
public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        //两个对象的Class类模版只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        //锁的存在
        new Thread(()->{
            phone1.sendMsg();
        },"A").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
//Phone3唯一的一个Class对象
class Phone3{

    //synchronized 锁的对象是方法的调用者！
    //static 静态方法
    //类一加载就有了！锁的是Class
    public static synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendMsg");
    }
    public static synchronized void call(){
        System.out.println("call");
    }
    //这里没有锁！不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

/**
 * 7、一个静态的同步方法，1个普通的同步方法    call方法
 * 8、新增两个对象 call方法
 */
public class Test4 {
    public static void main(String[] args) throws InterruptedException {
        //两个对象的Class类模版只有一个，static，锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        //锁的存在
        new Thread(()->{
            phone1.sendMsg();
        },"A").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
//Phone3唯一的一个Class对象
class Phone4{

    //静态同步方法    锁的是Class类模版
    public static synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendMsg");
    }
    //普通同步方法    锁的是对象
    public synchronized void call(){
        System.out.println("call");
    }
}

小结

new this 具体的一个手机

static 锁的是 Class 唯一的一个模版

6、集合类不安全

List 不安全

// java.util.ConcurrentModificationException 并发修改异常
public class ListTest {
    public static void main(String[] args) {
        //List<String> list = Arrays.asList("1", "2", "3");
        //list.forEach(System.out::println);

        //并发下ArrayList 不安全 Synchronized
        /**
         * 解决方案：
         * 1、List<String> list = new Vector<>();
         * 2、List<Object> list = Collections.synchronizedList(new ArrayList<>());
         * 3、List<Object> list = new CopyOnWriteArrayList<>();
         *
         */
        //ArrayList<Object> list = new ArrayList<>();
        // CopyOnWrite 写入时复制    COW    计算机程序设计领域的一种优化策略
        // 多个线程调用的时候，list，读取的时候是固定的，写入（覆盖）
        // 在写入的时候避免覆盖，造成数据问题
        // 读写分离
        // CopyOnWriteArrayList 比 Vector NB 在哪里？
        // Vector 读写操作都加上了synchronized 效率低；COWArrayList，用Lock锁，不需要同步

        List<Object> list = new CopyOnWriteArrayList<>();


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


    /**
     * CopyOnWriteArrayList add方法
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

学习方法推荐：

先会用
货比三家，寻找其他解决方案
分析源码

set 不安全

/**
 * 同理可证：ConcurrentModificationException
 */
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 < 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<>();
    }

//add set 本质就是 map key是无法重复的
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
//PRESENT 不变的值
private static final Object PRESENT = new Object();

HashMap 不安全

// ConcurrentModificationException
public class MapTest {
    public static void main(String[] args) {
        //map 是这样用的吗？不是，工作中不用HashMap
        //默认等价于什么 new HashMap<>(16,0.75)
        //HashMap<Object, Object> hashMap = new HashMap<>();
        //加载因子、初始化容量

        ConcurrentHashMap<String, String> hashMap = new ConcurrentHashMap<>();

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

    }
}

7、Callable

public interface Callable<V>
返回结果并可能引发异常的任务。实现者定义一个没有参数的单一方法，称为call 。

Callable接口类似于Runnable ，因为它们都是为其实例可能由另一个线程执行的类设计的。然而，A Runnable不返回结果，也不能抛出被检查的异常。

该Executors类包含的实用方法，从其他普通形式转换为Callable类。

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

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().start();   //怎么启动callable

        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask<>(thread);

        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();

        Integer o = (Integer) futureTask.get(); //获取Callable的返回结果，get方法可能会发生阻塞，放到最后
        //或者使用异步通信来处理
        System.out.println(o);
    }
}

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

细节：

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

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

CountDownLoatch

public class CountDownLatch
extends Object
允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

A CountDownLatch用给定的计数初始化。 await方法阻塞，直到由于countDown()方法的调用而导致当前计数达到零，之后所有等待线程被释放，并且任何后续的await 调用立即返回。这是一个一次性的现象 - 计数无法重置。如果您需要重置计数的版本，请考虑使用CyclicBarrier 。

A CountDownLatch是一种通用的同步工具，可用于多种用途。一个CountDownLatch为一个计数的CountDownLatch用作一个简单的开/关锁存器，或者门：所有线程调用await在门口等待，直到被调用countDown()的线程打开。一个CountDownLatch初始化N可以用来做一个线程等待，直到N个线程完成某项操作，或某些动作已经完成N次。

CountDownLatch一个有用的属性是，它不要求调用countDown线程等待计数到达零之前继续，它只是阻止任何线程通过await ，直到所有线程可以通过。

**示例用法：**这是一组类，其中一组工作线程使用两个倒计时锁存器：

第一个是启动信号，防止任何工作人员进入，直到驾驶员准备好继续前进;
第二个是完成信号，允许司机等到所有的工作人员完成。

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();
            },String.valueOf(i)).start();
        }
        countDownLatch.await(); //等待计数器归零，然后再向下执行

        System.out.println("close door");
    }
}

原理：

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

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

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

CyclicBarrier

public class CyclicBarrier
extends Object
允许一组线程全部等待彼此达到共同屏障点的同步辅助。循环阻塞在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。屏障被称为循环，因为它可以在等待的线程被释放之后重新使用。

A CyclicBarrier支持一个可选的Runnable命令，每个屏障点运行一次，在派对中的最后一个线程到达之后，但在任何线程释放之前。在任何一方继续进行之前，此屏障操作对更新共享状态很有用。

加法计数器

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         * 集齐7颗龙珠召唤神龙
         */
        //召唤龙珠的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功！");
        });

        for (int i = 1; i <=7 ; i++) {
            final int temp = i;
            //lambda能操作到 i 吗
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集第"+temp+"个龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore 信号量

public class Semaphore
extends Object
implements Serializable
一个计数信号量。在概念上，信号量维持一组许可证。如果有必要，每个acquire()都会阻塞，直到许可证可用，然后才能使用它。每个release()添加许可证，潜在地释放阻塞获取方。但是，没有使用实际的许可证对象; Semaphore只保留可用数量的计数，并相应地执行。

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() 释放

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

原理：

semaphore.acquire(); 获得信号量 - 1，假设如果已经满了，等待被释放为止

semaphore.release(); 释放信号量 + 1，唤醒等待的线程

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

9、读写锁

ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行，可以被多个线程同时读，写的时候只能有一个线程去写

/**
 * 独占锁（写锁）一次只能被一个线程占有
 * 共享锁（读锁）多个线程可以同时占有
 * ReadWriteLock
 * 读-读  可以共存
 * 读-写  不能共存
 * 写-写  不能共存
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        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()+"写入OK");
        } 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()+"读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

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

10、阻塞队列

Interface BlockingQueue

- 参数类型
  
  E - 此集合中保存的元素的类型
- All Superinterfaces:
  
  Collection ， Iterable ， Queue
- All Known Subinterfaces:
  
  BlockingDeque ， TransferQueue
- 所有已知实现类：
  
  ArrayBlockingQueue双阻塞队列， DelayQueue ， LinkedBlockingDeque ， LinkedBlockingQueue ， LinkedTransferQueue ， PriorityBlockingQueue ， SynchronousQueue同步队列

BlockingQueue

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

Interface Queue

- 参数类型
  
  E - 保存在此集合中的元素的类型
- All Superinterfaces:
  
  Collection ， Iterable
- All Known Subinterfaces:
  
  BlockingDeque ， BlockingQueue阻塞队列， Deque双端队列， TransferQueue
- 所有已知实现类：
  
  AbstractQueue非阻塞队列， ArrayBlockingQueue ， ArrayDeque ， ConcurrentLinkedDeque ， ConcurrentLinkedQueue ， DelayQueue ， LinkedBlockingDeque ， LinkedBlockingQueue ， LinkedList ， LinkedTransferQueue ， PriorityBlockingQueue ， PriorityQueue ， SynchronousQueue

在这里插入图片描述

学会使用BlockingQueue队列

四组API

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

public class Test {
    public static void main(String[] args) throws InterruptedException {
        test3();
    }

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

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));

        //查看队首元素
        System.out.println(blockingQueue.element());

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

        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("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));

        //查看队首元素
        System.out.println(blockingQueue.peek());

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

        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");
        //等待超过2秒就退出
        //blockingQueue.offer("d", 2, TimeUnit.SECONDS);

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

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        blockingQueue.poll(2, TimeUnit.SECONDS);

    }
}

SynchronousQueue 同步队列

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

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

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

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"T1").start();

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

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

11、线程池(重点)

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

池化技术

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

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

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

线程池的好处：

降低资源的消耗
提高相应的速度
方便管理

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

线程池：三大方法

// 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 e) {
            e.printStackTrace();
        } finally {
            //线程池用完了，程序关闭，关闭线程池
            threadPool.shutdown();
        }
    }
}

7大参数

源码分析

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

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

手动创建一个线程池

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

4种拒绝策略

// Executors 工具类、3大方法
/**
 * new ThreadPoolExecutor.AbortPolicy()         //银行满了，还有人进来，不处理这个人，抛出异常
 * new ThreadPoolExecutor.CallerRunsPolicy()    //哪来的去哪里！
 * new ThreadPoolExecutor.DiscardPolicy()       //队列满了，丢掉任务，不会抛出异常
 * new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争
 */
public class Demo01 {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争
        );
        try {
            //最大承载：Deque + max
            //超过 RejectedExecutionException
            for (int i = 1; i <= 9; i++) {
                // 使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" OK");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完了，程序关闭，关闭线程池
            threadPool.shutdown();
        }
    }
}

小结和拓展

最大的线程如何去设置

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

// 最大线程该如何定义
// 1、CPU 密集型，几核就定义为几，可以保持CPU的效率最高
// 2、IO 密集型，判断你的程序中十分耗IO的线程
// 程序  15个大型任务 io十分占用资源

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

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

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

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
// 泛型、枚举、反射
// lambda表达式、链式编程，函数式接口、Stream流式计算
// 超级多 FunctionalInterface
// 简化编程模型 在新版本的框架底层大量应用
// foreach(消费者类型的函数式接口)

Consumer、Function、Predicate、Supplier

代码测试：

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument 传入参数 T
     * @return the function result 返回类型 R
     */
    R apply(T t);

/**
 * 函数型接口，有一个输入参数，有一个输出
 * 只要是 函数型接口，可以用 lambda表达式简化
 */
public class Demo01 {
    public static void main(String[] args) {
        //工具类：输出输入的值
//        Function function = new Function<String, String>() {
//            @Override
//            public String apply(String str) {
//                return str;
//            }
//        };

        Function<String,String> function = (str)->{return str;};

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

Predicate 断定型接口

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}

/**
 * 断定型接口：有一个输入参数，返回值只能是 布尔值
 */
public class Demo02 {

    public static void main(String[] args) {
        //判断字符串是否无法为空
//        Predicate<String> predicate = new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.isEmpty();
//            }
//        };

        Predicate<String> predicate = (s)->{return s.isEmpty();};

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

    }
}

Consumer 消费型接口

@FunctionalInterface
public interface Consumer<T> {
    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

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

        Consumer<String> consumer = x -> System.out.println(x);
        consumer.accept("print");

    }
}

Supplier 供给型接口

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     * 没有参数只有返回值
     * @return a result
     */
    T get();
}

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

13、Stream流式计算

什么是Stream流式计算

大数据：存储+计算

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

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

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

        // 计算交给Stream流
        // 链式编程
        list.stream()
                .filter(u->{return u.getId()%2==0;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);
    }
}

// 有参，无参构造，get，set，toString方法
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;
}

14、ForkJoin 分支合并

什么是 ForkJoin

JDK 1.7，并行执行任务！提高效率，大数据量

大数据L：Map Reduce（把大任务拆分成小人物）

在这里插入图片描述

ForkJoin 特点：工作窃取

这个里面维护的都是双端队列
在这里插入图片描述

/**
 * 求和计算的任务
 * 3000 6000（ForkJoin） 9000（Stream并行流）
 * 1、如何使用forkjoinPool 通过它来执行
 * 2、计算任务 forkJoinPool.execute(ForkJoinTask task)
 * 3、计算类要继承 ForkJoinTask
 *
 */
public class ForkJoinDemo extends RecursiveTask<Long> {

    private long start; //1
    private long end;   //1000000000

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

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //test1(); //Time:5137 long类：297
        //test2(); //Time:3089 long类：204
        test3(); //Time:301

    }
    //普通程序员
    public static void test1(){
        long sum = 0L;
        long start = System.currentTimeMillis();
        for (long i = 1L; i <= 10_0000_0000L; i++) {
            sum+=i;
        }

        long end = System.currentTimeMillis();

        System.out.println("sum="+sum+" Time:"+(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+" Time:"+(end-start));
    }
    //Stream并行流（）
    public static void test3(){
        long start = System.currentTimeMillis();
        long reduce = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        
        System.out.println("sum="+reduce+"Time:"+(end-start));
    }
}

15、异步回调

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

Class CompletableFuture

java.lang.Object
- java.util.concurrent.CompletableFuture
- All Implemented Interfaces:
  
  CompletionStage ， Future

/**
 * 异步调用：Ajax
 * 异步执行
 * 成功回调
 * 失败回调
 */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 没有返回值的 runAsync 异步回调
//        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
//            try {
//                TimeUnit.SECONDS.sleep(2);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"runAsync=>Void");
//        });
//        System.out.println("111");
//
//        completableFuture.get(); //获取阻塞执行结果
        // 有返回值的 supplyAsync 异步回调
        // ajax 成功和失败的回调
        // 返回的是错误信息
        CompletableFuture<Integer> uCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            //int i= 10/0;
            return 1024;
        });

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

        /**
         * success Code 200
         * error Code 404 500
         */
    }
}

16、JMM

请你谈谈对Volatile的理解

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

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

JMM

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

关于JMM一些同步的约定：

线程解锁前，必须把共享变量立刻刷回主存（缓存一致性原则）
线程加锁前，必须读取主存中的最新值到工作内存中！
加锁和解锁是同一把锁

线程 工作内存、主内存

8种操作：
在这里插入图片描述

Java虚拟机内存模型中定义了8种内存交互操作，虚拟机实现必须保证每个操作都是原子的，不可再分的：

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

Java内存模型对上述8种操作有如下的约束：

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

在这里插入图片描述

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

17、Volatile

保证可见性

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

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

            }
        }).start();

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

        num = 1;
        System.out.println(num);
    }
}

不保证原子性

原子性：不可分割

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

// volatile 不保证原子性
public class VDemo02 {

    private volatile static int num = 0;

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

    public static void main(String[] args) {

        //理论上结果应该为2万，产生幻读，导致数据丢失
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        // main gc
        while (Thread.activeCount()>2){
           Thread.yield(); //礼让
        }

        System.out.println(Thread.currentThread().getName()+" "+num);

    }
}

如果不加 lock 和 synchronized，怎样保证原子性
在这里插入图片描述

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

// volatile 不保证原子性
public class VDemo02 {
    // 原子类 Integer
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
        // num++;  //不是一个原子性操作
        // AtomicInteger +1 方法， CAS
        num.getAndIncrement();
    }

    public static void main(String[] args) {

        //理论上结果应该为2万，产生幻读，导致数据丢失
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        // main gc
        while (Thread.activeCount()>2){
           Thread.yield(); //礼让
        }

        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

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

指令重排

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

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

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

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

我们所期望的：1234 2134 1324
可不可能是 4123

可能造成影响的结果：a, b, c, d 默认都是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指令，作用：

保证特定的操作的执行顺序！
可以保证某些变量的内存可见性（利用这些特性，就可以保持volatile实现可见性）

在这里插入图片描述

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

18、深入单例模式

饿汉式、DCL懒汉式，深究！

饿汉式

// 饿汉式单例
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 Hungry(){

    }

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }

}

DCL 懒汉式

// 懒汉式单例
// 道高一尺，魔高一丈
/**
 * new LazyMan()
 * 1、分配内存空间
 * 2、执行构造方法，初始化对象
 * 3、把这个对象指向这个空间
 * 123
 * 132 A
 *     B // 此时 lazyMan 还没有完成构造，
 *
 *
 */
public class LazyMan {

    private static boolean flag = false;

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

    private volatile static LazyMan lazyMan;

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

    // 反射
    public static void main(String[] args) throws Exception {
        //LazyMan instance = LazyMan.getInstance();

        Field flag = LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);

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

        flag.set(instance, false);

        LazyMan instance1 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);
    }
}

静态内部类

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

    }

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

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

}

单例不安全，反射

枚举

// enum 是什么？ 本身也是一个Class类
public enum EnumSingle {

    INSTANCE;

    public  EnumSingle getInstance(){
        return INSTANCE;
    }

}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;

        // java.lang.NoSuchMethodException: com.single.EnumSingle.<init>()
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);

        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);

    }
}

枚举类型的最终反编译源码

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

19、深入理解CAS

什么是CAS

大厂必须要深入研究底层！有所突破！ 修内功，操作系统，计算机网络

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

        // 期望、更新
        // public final boolean compareAndSet(int expect, int update)
        // 如果期望的值达到了，就更新，否则不更新，CAS 是 CPU 的并发原语
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

        atomicInteger.getAndIncrement();//++

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

    }
}

深入理解 Unsafe

在这里插入图片描述

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

缺点：

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

CAS：ABA问题（狸猫换太子）

在这里插入图片描述

public class CASDemo {

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

        // 对于我们平时写的SQL：乐观锁！
        
        // 期望、更新
        // public final boolean compareAndSet(int expect, int update)
        // 如果期望的值达到了，就更新，否则不更新，CAS 是 CPU 的并发原语
        // ==================捣乱的线程
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

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

        // ==================期望的线程
        System.out.println(atomicInteger.compareAndSet(2020, 6666));
        System.out.println(atomicInteger.get());

    }
}

20、原子引用

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

带版本号的原子操作

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

在这里插入图片描述

public class CASDemo {

    // AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
    // 正常在业务操作，这里面比较的都是一个个对象
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);

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

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp(); // 获得版本号
            System.out.println("a1=>"+stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // true
            System.out.println(atomicStampedReference.compareAndSet(1, 2,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a2=>"+atomicStampedReference.getStamp());

            System.out.println(atomicStampedReference.compareAndSet(2, 1,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a3=>"+atomicStampedReference.getStamp());

        },"a").start();

        // 乐观锁的原理相同
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp(); // 获得版本号
            System.out.println("b1=>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // false 版本号已被a线程篡改
            System.out.println(atomicStampedReference.compareAndSet(1, 6,
                    stamp, stamp + 1));
            System.out.println("b2=>"+stamp);

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

21、各种锁的理解

1、公平锁、非公平锁

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

非公平锁：非常不公平，可以插队（默认都是非公平），3s，3h

public ReentrantLock() {
    sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
}

2、可重入锁

可重入锁（递归锁）

在这里插入图片描述

synchronized

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

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

    }


}
class Phone{

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

    }

}

lock

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

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

    }
}
class Phone2{
    Lock lock = new ReentrantLock();

    public synchronized void sms(){
        // 细节问题：lock.lock(); lock.unlock();
        // lock 锁必须配对，否则就会锁在里面
        lock.lock();

        try {
            System.out.println(Thread.currentThread().getName()+"sms");
            call(); // 这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public synchronized void call(){
        lock.lock();

        try {
            System.out.println(Thread.currentThread().getName()+"call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

3、自旋锁

SpinLock

public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);
    } while (!compareAndSwapInt(o, offset, v, v + delta));
    return v;
}

自定义锁测试

/**
 * 自旋锁
 */
public class SpinlockDemo {
    // int 0
    // Thread null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

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

        //自旋锁
        while (!atomicReference.compareAndSet(null, thread)){

        }

    }

    //解锁
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"==> myUnlock");

        //自旋锁
        atomicReference.compareAndSet(thread,null);

    }
}

测试

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

        //底层使用的自旋锁
        SpinlockDemo lock = new SpinlockDemo();

        new Thread(()->{
            lock.myLock();

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }

        },"T1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            lock.myLock();

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

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

4、死锁

死锁是什么

在这里插入图片描述

死锁测试，怎么排除死锁：

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

        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA,lockB),"T1").start();
        new Thread(new MyThread(lockB,lockA),"T2").start();

    }
}

class MyThread implements Runnable{

    private String lockA;
    private String lockB;

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

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

            }
        }
    }
}

解决问题

使用jps -l定位进程号
使jstack 进程号来找到死锁问题

在这里插入图片描述

面试或者工作中，排查问题

日志
堆栈

James Cheung

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
JUC 并发编程

JUC并发编程1、什么是JUCjava.util工具包、包、分类业务：普通的线程代码 ThreadRunnable 没有返回值、效率相比Callable相对较低2、线程和进程回顾线程、进程，如果不能使用一句话说出来的技术，不扎实进程是操作系统调用的最小单位，线程是CPU调度的最小单位进程：一个程序，QQ.exe，程序的集合；一个进程往往可以包含多个线程，至少包含一个！Java默认有几个线程？2个 main、GC线程：开了一个进程Typora，写字，自动保存（线程负责的）对于Jav
复制链接

扫一扫