# 多线程如果你对多线程没什么了解，那么从入门模块开始。如果你已经入门了多线程（知道基础的线程创建、死锁、synchronized、lock等，并不代表后面不讲，只是后面需要有基础才好深入），那么从juc模块开始。（[点此跳转](#jump) ） # 入门模块 ### 基本概念解释 1. 程序：静态代码，一串指令的集合 2. 进程：资源分配的单位 3. 线程：调度和执行的单位，有独立的运行栈和程序计数器 4. 并行：多个CPU同时执行多个任务 5. 并发：单个CPU同时执行多个任务 ## 多线程的创建 & 使用 #### 方法1：继承Thread类步骤： 1. `extends Thread` 2. 重写`run()`方法 3. 创建该类的子对象 4. 调用子对象的`start()`方法 ```java class PrimeThread extends Thread { public void run() { // compute primes larger than minPrime } } //使用方式 PrimeThread p = new PrimeThread(); p.start(); ``` #### 方法2：实现Runnable接口步骤： 1. `implements Runnable` 2. 实现`run()`方法 3. 创建子对象 4. 将子对象传入 `new Thread()`构造性的线程 5. 调用线程的`start()`方法注意事项：
一般我们采用实现接口的方式，而不是选择方法一，因为我们可以通过同意对象传造出多个线程，这样可以做到数据域共享，不过并不代表线程安全了！ ```java class PrimeRun implements Runnable { long minPrime; PrimeRun(long minPrime) { this.minPrime = minPrime; } public void run() { // compute primes larger than minPrime } } //使用方式 PrimeRun p = new PrimeRun(143); new Thread(p).start(); ``` #### 方法3：实现Callable接口好处： 1. 相比实现Runnable，实现该接口方法call()支持泛型返回值 2. call()方法可以抛出异常 3. 可以借助FutureTask类获取返回结果 ##### 普及一下FutureTask FutureTask类能通过get()方法，获取实现Callable接口类的返回值，该类是Future接口的唯一实现类步骤： 1. `implements Callable` 2. 重写call()方法 3. 创建子对象 4. 构造一个FutureTask类的实例，传入参数为子对象 5. 构造一个Thread类的示例并`start()`，传入参数为FutureTask类的示例 6. 调用FutureTask类的实例的get(),获取结果示例： ```java package com.zzt;/* * @author: G_night * 转载请申明作者 * Reprint please state the author * 实现Callable接口 */ import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; class myCall implements Callable{ @Override public Integer call() throws Exception { int num=0; for(int i=1;i<=100;i++){ num+=i; } return num; } } public class MyThread { public static void main(String[] args) { myCall call=new myCall(); FutureTask futureTask=new FutureTask(call); new Thread(futureTask).start(); try { Integer num=futureTask.get(); System.out.println(num); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } } ``` #### 方法4：使用线程池好处： 1. 提高响应速度（减少创建时间） 2. 降低资源消耗（可重用） 3. 便于线程管理 ##### ExecutorService ExecutorService是线程池的接口，实现类为ThreadPoolExecutor，Executors是线程池创建的工具类步骤： 1. 使用Executors工具类创建线程池，返回ThreadPoolExecutor 2. 设置线程池所需参数 3. 调用ThreadPoolExecutor类执行方法 --> execute、submit等 ##### 线程池的常用方法： Executors工具类（创造线程池）的常用方法： ```java newCacheThreadPool() //根据需求创造线程池 newFIxedThreadPool() //可重用的固定线程池（常用方法） newSingleThreadExecutor() //单个线程的线程池 newScheduledThreadPool() //创建一个线程池。在给定安排的延迟后执行 ``` ThreadPoolExecutor（线程池）的常用方法： ```java executoe() //传入实现Runnable接口的实例 submit() //传入实现Callable or Runnable接口的实例 /* submit() 一般是传入实现Callable接口的实例然后用FutureTask类接收返回值 */ shutdown() //关闭线程池 ``` 设置线程池参数！ ```java corePoolSize() //设置大小 maximumPoolSize() //最大线程数 keepAliveTime() //线程无任务时，最多保持多长时间后终止 ``` 示例： ```java package com.zzt;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; /** * 线程池的使用示例 **/ class myRunnable implements Runnable{ @Override public void run(){ System.out.println("执行完成"); } } public class MyThreadPool { public static void main(String[] args) { // 1. 使用工具类初始化线程池 ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newFixedThreadPool(10); // 2. 实例化实现Runnable接口的对象 myRunnable myRunnable = new myRunnable(); // 3. 执行线程 service.execute(myRunnable); // 4. 关闭线程池 service.shutdown(); } } ``` ### 线程的一些常用方法 ```java Thread.current() //这个方法可以获取当前类的线程，≈this start() //启动线程 run() //需要重写的方法 setName() //设置线程名字 yield() //将控制权暂时给别的线程 join() //插入下运行并完成，需要先启动start stop() //强制结束，过时方法，不推荐使用！！ sleep() //休息（ms） setPriority(int) //设置优先级 1~10 getPriority() //获取优先级 /* 优先级最大 --- Thread.Max_PRIORITY --- 10 优先级最低 --- Thread.MIN_PRIORITY --- 1 常规优先级（默认） --- Thread.NORM_PRIORITY --- 5 并不是优先级越高就越快完成，只是率先完成的概率大一点 */ ``` ## 重点：线程的同步问题使用多线程的时候，操纵访问同一个数据域就有可能出现同步问题。简而言之，假设我们对一个数据修改了，然后要输出修改后的数据，可是修改完后的一瞬间又有线程修改了数据，这样我们看到的是经过二次修改的数据，而不是当此修改完的数据，显示会出现错误。 ### 线程同步问题的解决方式 #### 方法1：同步代码块把需要同步的代码写在synchronized中，括号为同步监视器（俗称锁），同步监视器可以是仍以object对象，不过要注意需要同步的要使用同一个锁，不然无法实现效果 ```java synchronized(this){ //代码块 } /* 若使用实现接口的方式创建的线程，那么可以用this作为同步监视器若使用继承Thread类的方式创建线程，使用this会导致锁不一样，所以采用 ---> 类名.class 的方式更好当然如果自己写了一个类当锁也可以 */ ``` 我们也可以在进入同步代码块前加一些条件判断，这样可以提高效率，不需要一个个线程等着排队，这个在我们同步代码块里面有条件判断的时候适用，看情况而定。 #### 方法2：同步方法同步方法其实就是把同步监视器省去了，在方法修饰符后加上synchronized，本质同步监视器就是：当前类本身（静态方法的当前类）or this（非静态方法的当前对象） ```JAVA public synchronized void test(){ //代码 } ``` 注意我们这样保护线程安全，要保证是对一个对象作为锁，才是安全的 #### 方法3：同步锁这个是JDK1.5+推出的，推荐使用这个，灵活性更强 ```java class X{ //定义锁对象 private final ReentrantLock lock=new ReentrantLock(); //定义需要保证线程安全的方法 public void m(){ //加锁 lock.lock(); try{ //...method body } //使用finally块来保证释放锁 finally{ lock.unlock(); } } } ``` 包含两个方法： 1. lock() --> 上锁 --> 写在try之前 2. unlock() --> 解锁 --> 写在finally内 #### 死锁现象当我们出现两个线程共同争夺一把锁，都互相抓着不放手的时候就会出现死锁现象死锁现象的代码演示： ```java package com.zzt; /** * 多线程死锁演示 * * @author ZZT * */ public class MyThread { public static void main(String[] args) { Object s1=new Object(); Object s2=new Object(); new Thread() { @Override public void run() { synchronized (s1) { System.out.println("进入第一线程 -- 获得锁s1"); try { Thread.sleep(100); }catch(InterruptedException e) { e.printStackTrace(); } synchronized (s2) { System.out.println("进入第一线程 -- 获得锁s2"); } } } }.start(); new Thread() { @Override public void run() { synchronized (s2) { System.out.println("进入第二线程 -- 获得锁s2"); try { Thread.sleep(100); }catch(InterruptedException e) { e.printStackTrace(); } synchronized (s1) { System.out.println("进入第二线程 --获得锁s1"); } } } }.start(); } } /** 增加sleep()是为了提高死锁概率，方便演示 **/ ``` 结果就是： ```xml 进入第一线程 -- 获得锁s1 进入第二线程 -- 获得锁s2 ``` 二者都不能执行完，程序会卡着不动会发现第一个线程拿了s1执行完需要拿s2，可是第二个线程拿了s2后继续执行需要拿s1。这时候就会产生矛盾，线程1需要在拿到s1后拿到s2才能执行完全部，而s2被线程2抓着不放，所以产生死锁。 ##### 避免死锁的建议平常使用中要减少嵌套同步，减少使用同步资源，优化算法（比如少sleep） --- 死锁的出现是有概率的，但是有可能就要处理 ### 线程的通信 ```java notify() //唤醒一个线程，根据优先级唤醒 notifyAll() //唤醒全部线程 wait() //休息，并释放同步监视器！ ``` 这三个方法必须在同步方法 or 同步代码块中使用，调用对象都是`同步监视器（锁）` ## 面试题： ##### 问：synchronized和lock有什么异同？答： 1. 同：二者都能作为解决线程安全问题的方式 2. 异：synchronized是执行完方法后自动释放同步监视器，而lock需要手动启动和释放同步监视器注：后面进阶模块有更详细的解释~ ##### 问：sleep()和wait()有什么异同？答： 1. 同：都可以使当前进程进入阻塞态 2. 异： 1. sleep()在Thread中，wait()在Obejct中； 2. 范围不同。wait()必须在同步代码块or同步方法内使用，而sleep()则不需要； 3. sleep()不释放锁，而wait()释放锁。 ##### 问：写一个饿汉式和懒汉式的单例模式答： 1. 饿汉式（线程安全的） ```java public class X{ private static X a=new X(); private X(){} public static X getInstance(){ return a; } } ``` 2. 懒汉式（线程不安全，所以要加synchronized变成线程安全） ```java public class X{ private static X a; private X(){} private static Object key = new Obejct(); public static X getInstance(){ if(a == null){//提高效率 synchronized (key) {//线程安全模式 if(a==null){ a = new X(); } } } return a; } } ``` # JUC进阶模块 **先回答几个问题再往下走** # 线程基础知识 1. 进程：资源分配的单位 2. 线程：调度和执行的基本单位 > 一个进程往往可以包含多个线程，至少包含一个！ > > 问：Java默认有几个线程？ > > 答：2 个 ---> mian、GC ### 1. java真可开线程？回答：不行！实际上 **private native** 修饰的方法调用c++开辟的 ### 2. 并发和并行的区别？ 1. 并发：多线程操作同一个资源 · CPU 一核，模拟出来多条线程，快速交替达到效果 2. 并行：多个任务同时执行 · CPU 多核，多个线程可以同时执行 **并发编程的本质：充分利用CPU的资源** ### 3. java线程有几个状态？六个！ ```java public enum State { // 新生 NEW, // 运行 RUNNABLE, // 阻塞 BLOCKED, // 等待 WAITING, // 超时等待 TIMED_WAITING, // 终止 TERMINATED; } ``` ### 4. sleep和wait区别？ 1. 来自的类 sleep ----> Thread wait -----> Object 2. 锁释放问题 sleep ----> 不释放锁 wait -----> 释放锁 3. 作用范围 sleep ----> 用于线程中任何地方 wait -----> 只能用于同步代码块、同步方法中 ### 5. synchronized和lock锁的区别 Lock主要的类：**ReentrantLock** >1. synchronized为关键字，lock为类 >2. synchronized不可判断当前状态，lock可以 >3. synchronized自动释放锁，lock手动释放锁 >4. synchronized适合锁少量代码，lock适合大量 >5. synchronized不可中断，lock可以中断 >6. synchronized非公平锁（可插队），lock可以修改为公平锁（默认非公平） ### 6. 生产者消费者问题一般该问题都分为三步：判断等待 ---> 处理业务 ---> 唤醒线程 **synchronized版本** 需要注意的地方：注意判断条件不可以用if，再多几个线程会出问题，必须要使用while ```java /*** * @author: G_night * 转载请声明作者 * Reprint please state the author ***/ public class producer_consumer { public static void main(String[] args) { Person person = new Person(); for (int i=0;i<6;i++){ new Thread(()->{ person.produce(); },"producer").start(); new Thread(()->{ person.consume(); },"consumer").start(); } } } class Person{ int num=0;//产品数量 public synchronized void produce(){ while(num!=0){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } num++; this.notifyAll(); System.out.println("生产了商品，目前商品存余："+num); } public synchronized void consume(){ while(num==0){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } num--; this.notifyAll(); System.out.println("生产了商品，目前商品存余："+num); } } ``` **lock版本** ```java import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /*** * * * @author: G_night * 转载请声明作者 * Reprint please state the author ***/ public class producer_consumer { public static void main(String[] args) { Person person = new Person(); for (int i=0;i<6;i++){ new Thread(()->{ person.produce(); },"producer").start(); new Thread(()->{ person.consume(); },"consumer").start(); } } } class Person{ private int num=0;//产品数量 Lock lock=new ReentrantLock(); Condition condition=lock.newCondition(); public void produce(){ lock.lock(); try{ while(num!=0){ try { condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } } num++; condition.signalAll(); System.out.println("生产了商品，目前商品存余："+num); }finally { lock.unlock(); } } public void consume(){ lock.lock(); try{ while(num==0){ try { condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } } num--; condition.signalAll(); System.out.println("生产了商品，目前商品存余："+num); }finally { lock.unlock(); } } } ``` **按指定顺序执行线程** ```java import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /*** * @author: G_night * 转载请声明作者 * Reprint please state the author ***/ public class PrintABC { public static void main(String[] args) { Print print = new Print(); for(int i=0;i<6;i++){ new Thread(()->{ print.printA(); },"a").start(); new Thread(()->{ print.printB(); },"b").start(); new Thread(()->{ print.printC(); },"c").start(); } } } class Print{ private int num=1;//区分三者执行条件 Lock lock=new ReentrantLock(); Condition conditionA=lock.newCondition(); Condition conditionB=lock.newCondition(); Condition conditionC=lock.newCondition(); public void printA(){ lock.lock(); try{ while(num!=1){ conditionA.await(); } System.out.println(Thread.currentThread().getName()+"执行了"); num=2; conditionB.signal(); } catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); } } public void printB(){ lock.lock(); try{ while(num!=2){ conditionB.await(); } System.out.println(Thread.currentThread().getName()+"执行了"); num=3; conditionC.signal(); } catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); } } public void printC(){ lock.lock(); try{ while(num!=3){ conditionC.await(); } System.out.println(Thread.currentThread().getName()+"执行了"); num=1; conditionA.signal(); } catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); } } } ``` ### 7. 什么是可重入锁？可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。ReentrantLock和synchronized都是可重入锁。也就是说一个线程获取了某个锁，执行过程中亦可以正常获得该锁，不会出现死锁。 ```java import java.util.concurrent.locks.ReentrantLock; public class suo { public static void main(String[] args) { suotry suotry = new suotry(); suotry.say(); } } class suotry{ public synchronized void say(){//获得了锁 System.out.println("------------say-----------"); hello();//进入hello } public synchronized void hello(){//允许再次获得锁（搭配say看） System.out.println("==========hello============"); } } ``` # 深入理解锁 8锁现象，实际对应的就是8个问题，学完以后可以更好理解**锁**，明白锁的对象 **synchronized锁对象的区分** 当synchronized修饰的方法为**static**的时候，锁的对象是 **class类模板** 当sychronized修饰的方法为**非静态方法**的时候，锁的对象是 **实例对象** **例子1** 下面先打印A还是B？ ```java import java.util.concurrent.TimeUnit; /*** * @author: G_night * 转载请声明作者 * Reprint please state the author ***/ public class lock8 { public static void main(String[] args) { PrintAB printAB = new PrintAB(); new Thread(()->{ printAB.A(); },"a").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(()->{ printAB.B(); },"b").start(); } } class PrintAB{ public synchronized void A(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("打印A"); } public synchronized void B(){ System.out.println("打印B"); } } ``` 答案：先打印A 然后打印B 原因：二者锁是同一个对象printAB（实例），A拿到以后虽然休息但是不释放锁，所以B要等A释放以后才可以执行 **例子2** 下面先打印A还是B？ ```java import java.util.concurrent.TimeUnit; /*** * @author: G_night * 转载请声明作者 * Reprint please state the author ***/ public class lock8 { public static void main(String[] args) { PrintAB printAB = new PrintAB(); new Thread(()->{ printAB.A(); },"a").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(()->{ printAB.B(); },"b").start(); } } class PrintAB{ public synchronized static void A(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("打印A"); } public synchronized void B(){ System.out.println("打印B"); } } ``` 答案：先打印B 然后打印A 原因：A的锁是PrintAB这个**类模板(唯一的！！)**，B的锁是**printAB这个实例对象**，在A休息4s的时间内，B仍然可以正常执行，故先打印B然后打印A # 集合类不安全 list、set、map都线程不安全，多线程情况下启动多个线程去修改集合类，可能会报错 `java.util.ConcurrentModificationException` **线程安全的方法** 那么就要想办法实现线程安全。 1. 使用`Collections.synchronized~`创建List、set、map（注：~的意思是可以接上List、Set、Map等词） 2. 使用`CopyOnWriteArray~`读写分离创建集合（后面有讲到读写锁） > 写时复制，CopyOnWrite容器即写时复制的容器，往一个容器中添加元素的时候，不直接往当前容器Object[]添加，而是先将Object[]进行copy，复制出一个新的容器object[] newElements，然后新的容器Object[] newElements里添加原始，添加元素完后，在将原容器的引用指向新的容器 setArray(newElements)。 > > 好处：可以对copyOnWrite容器进行并发读取，而不需要加锁，因为当前容器不需要添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器 ```java import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.CopyOnWriteArraySet; /*** * @author: G_night * 转载请声明作者 * Reprint please state the author ***/ public class collection_thread { public static void main(String[] args) { //线程安全的方法1 List list = Collections.synchronizedList(new ArrayList<>()); Set set = Collections.synchronizedSet(new HashSet<>()); //线程安全的方法2 List copyOnWriteArrayList=new CopyOnWriteArrayList(); Set copyOnWriteArraySet=new CopyOnWriteArraySet(); //hashmap线程安全的方法 Map map = new ConcurrentHashMap<>(); //演示 for (int i = 1; i <=30; i++) { new Thread(()->{ map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring( 0,5)); System.out.println(map); },String.valueOf(i)).start(); } } } ``` 在了解ConcurrentHashMap之前还要了解一下什么是**CAS**操作 ### CAS操作 CAS：Compare and Swap，即比较再交换。区别于synchronized的悲观锁，CAS可以算是一种乐观锁。 **CAS简单理解** CAS是一种无锁算法，CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。假设t1在与t2线程竞争中线程t1能去更新变量的值，而其他线程都失败。（失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次发起尝试）。t1线程去更新变量值改为**num+1**，然后写到内存中。此时对于t2来说，内存值变为了**num+1**，与预期值**num**不一致，就操作失败了。 **CAS问题** > CAS（比较并交换）是CPU指令级的操作，只有一步原子操作，所以非常快。而且CAS避免了请求操作系统来裁定锁的问题，不用麻烦操作系统，直接在CPU内部就搞定了。但CAS就没有开销了吗？ > > - 不！有cache miss的情况。 > CAS ：比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！ > > 缺点： > > 1、循环会耗时 > > 2、一次性只能保证一个共享变量的原子性 > > 3、ABA问题 **ABA问题** 过程中数值被改变但是又改回了原来的值，虽然交换成功但是其实原本对象以及被改变了。 **ABA的危害** 假设一个栈有多个数据，前面两个数据被一个线程取走，第三个数据又和第一个一样，此时原本要修改第一个数据的线程通过cas操作，发现第三个数据和第一个数据相等，然后修改了第三个数据，那么就会造成问题。 ```java package CAS;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ import java.util.concurrent.atomic.AtomicInteger; public class casDemo { public static void main(String[] args) { AtomicInteger atomicInteger = new AtomicInteger(1); // ============== 捣乱的线程 ================== System.out.println(atomicInteger.compareAndSet(1, 2)); System.out.println(atomicInteger.get()); System.out.println(atomicInteger.compareAndSet(2, 1)); System.out.println(atomicInteger.get()); // ============== 期望的线程 ================== System.out.println(atomicInteger.compareAndSet(1, 3)); System.out.println(atomicInteger.get()); } } ``` **解决方式** 加入版本号一起对比，就可以防止ABA问题。 ```java package CAS;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicStampedReference; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class casDemo { // 业务中，一般比较的是一个个对象。第二个参数是初始版本号 static AtomicStampedReference atomicStampedReference = new AtomicStampedReference<>(1,1); public static void main(String[] args) { new Thread(()->{ int stamp = atomicStampedReference.getStamp(); // 获得版本号 System.out.println("版本号 => "+stamp); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } Lock lock = new ReentrantLock(true); atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1); System.out.println("版本号 => "+atomicStampedReference.getStamp()); System.out.println("捣乱线程执行："+atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1)); System.out.println("版本号 => "+atomicStampedReference.getStamp()); },"a").start(); new Thread(()->{ int stamp = atomicStampedReference.getStamp(); // 获得版本号 System.out.println("期望获取的版本号 => "+stamp); //休息长时间，让捣乱线程执行 try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("期望线程执行："+atomicStampedReference.compareAndSet(1, 6, stamp, stamp + 1)); System.out.println("版本号 => "+atomicStampedReference.getStamp()); },"b").start(); } } ``` ### ConcurrentHashMap底层原理 (JDK1.8) 重要成员变量 > ① table：默认为null，初始化发生在第一次插入操作，默认大小为16的数组，用来存储Node节点数据，扩容时大小总是2的幂次方。 > ② nextTable：默认为null，扩容时新生成的数组，其大小为原数组的两倍。 > ③ sizeCtl ：默认为0，用来控制table的初始化和扩容操作，具体应用在后续会体现出来。 > > - -1 代表table正在初始化 > - -N 表示有N-1个线程正在进行扩容操作 > 其余情况： > 1、如果table未初始化，表示table需要初始化的大小。 > 2、如果table初始化完成，表示table的容量，默认是table大小的0.75倍，居然用这个公式算0.75（n - (n >>> 2)）。 > Node：保存key，value及key的hash值的数据结构。其中value和next都用volatile修饰，保证并发的可见性。 **put操作描述** put操作采用 **CAS+synchronized** 实现并发插入或更新操作： 1. 根据key进行两次hash算法得到hash值。 2. 判断Node数组是否为空，如果为空进行初始化。 3. 根据hash值得出所在的数组的位置，并判断当前数组里有没有链表存在，没有就通过CAS操作将元素加入到当前位置中。 4. 如果取出来的节点的hash值是MOVED(-1)的话，则表示当前正在对这个数组进行扩容，复制到新的数组，则当前线程也去帮助复制 5. 如果当前数组位置已经存在元素了，就先用synchronized加锁，然后再判断当前位置是链表，还是红黑树，再对比hash值和equls，hash值相同的，如果key相同就覆盖，key不相同就挂在当前链表后面，hash值不同，就挂在新节点上。 6. 如果是树的话，则调用putTreeVal方法把这个元素添加到树中去，最后在添加完成之后，会判断在该节点处共有多少个节点（注意是添加前的个数），如果达到8个以上了的话，则调用treeifyBin方法来尝试将处的链表转为树，或者扩容数组 **扩容描述** 当table的元素数量达到容量阈值sizeCtl，需要对table进行扩容： - 构建一个nextTable，大小为table两倍 - 把table的数据复制到nextTable中。 - 同时检测到某个table链表元素**小于6个**了的红黑树，就会自动把红黑树又转为链表结构。如何在扩容时，并发地复制与插入？ 1. 遍历整个table，当前节点为空，则采用CAS的方式在当前位置放入fwd 2. 当前节点已经为fwd(with hash field “MOVED”)，则已经有有线程处理完了了，直接跳过，这里是控制并发扩容的核心 3. 当前节点为链表节点或红黑树，重新计算链表节点的hash值，移动到nextTable相应的位置（构建了一个反序链表和顺序链表，分别放置在i和i+n的位置上）。移动完成后，用Unsafe.putObjectVolatile在tab的原位置赋为为fwd, 表示当前节点已经完成扩容。 ### JDK1.7&JDK1.8的区别 JDK 1.7： 1. 同步机制：分段锁，每个segment继承ReentrantLock 2. 存储结构：数组+链表 3. 键值对： HashEntry 4. put操作：多个线程同时竞争获取同一个segment锁，获取成功的线程更新map；失败的线程尝试多次获取锁仍未成功，则挂起线程，等待释放锁 5. size的实现：统计每个Segment对象中的元素个数，然后进行累加，但是这种方式计算出来的结果并不一样的准确的。先采用不加锁的方式，连续计算元素的个数，最多计算3次：如果前后两次计算结果相同，则说明计算出来的元素个数是准确的；如果前后两次计算结果都不同，则给每个Segment进行加锁，再计算一次元素的个数 JDK 1.8： 1. 同步机制： CAS + synchronized保证并发更新 2. 存储结构：数组+链表+红黑树 3. 键值对：Node 4. put操作：访问相应的bucket时，使用sychronizeded关键字，防止多个线程同时操作同一个bucket，如果该节点的hash不小于0，则遍历链表更新节点或插入新节点；如果该节点是TreeBin类型的节点，说明是红黑树结构，则通过putTreeVal方法往红黑树中插入节点；更新了节点数量，还要考虑扩容和链表转红黑树 5. size的实现：通过累加baseCount和CounterCell数组中的数量，即可得到元素的总个数 ### 思考为什么JDK1.8做了如此改动？总结如下思考 1. JDK1.8的实现降低锁的粒度，JDK1.7版本锁的粒度是基于Segment的，包含多个HashEntry，而JDK1.8锁的粒度就是**首节点** 2. JDK1.8版本的数据结构变得更加简单，使得操作也更加清晰流畅，因为已经使用synchronized来进行同步，所以不需要分段锁的概念，也就不需要Segment这种数据结构了，由于粒度的降低，实现的复杂度也增加 3. JDK1.8使用红黑树来优化链表，基于长度很长的链表的遍历是一个很漫长的过程，而红黑树的遍历效率是很快的，代替一定阈值的链表，这样形成一个最佳拍档 4. JDK1.8为什么使用内置锁synchronized来代替重入锁ReentrantLock，原因如下： ```bash 1.因为粒度降低了，在相对而言的低粒度加锁方式，synchronized并不比ReentrantLock差，在粗粒度加锁中 ReentrantLock可能通过Condition来控制各个低粒度的边界，更加的灵活，而在低粒度中，Condition的优势就没有了 2.JVM的开发团队从来都没有放弃synchronized，而且基于JVM的synchronized优化空间更大，使用内嵌的关键字比使用API更加自然 3.在大量的数据操作下，对于JVM的内存压力，基于API的ReentrantLock会开销更多的内存，虽然不是瓶颈，但是也是一个选择依据 ``` # AQS介绍 AQS 的全称为（AbstractQueuedSynchronizer），这个类在 java.util.concurrent.locks 包下面。 AQS 是一个用来构建锁和同步器的框架，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，诸如 ReentrantLock，Semaphore，ReentrantReadWriteLock，SynchronousQueue，FutureTask(jdk1.7) 等等皆是基于 AQS 的。 **AQS 核心思想：** > （1）如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。 > > （2）如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制 AQS 是用 **CLH 队列锁**实现的，即将暂时获取不到锁的线程加入到队列中。 > > 介绍：CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS 是将每条请求共享资源的线程封装成一个 CLH 锁队列的一个结点（Node）来实现锁的分配。 **AQS状态标识** ```java private volatile int state;//共享变量，使用volatile修饰保证线程可见性 //返回同步状态的当前值 protected final int getState() { return state; } // 设置同步状态的值 protected final void setState(int newState) { state = newState; } //使用CAS操作将同步状态值设置为给定值update（保证原子性） protected final boolean compareAndSetState(int expect, int update) { return unsafe.compareAndSwapInt(this, stateOffset, expect, update); } ``` **AQS 使用了模板方法模式，自定义同步器时需要重写下面几个 AQS 提供的模板方法：** ```java isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。 tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。 tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。 tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。 tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。 ``` # 常用辅助类这里介绍常用的辅助类，必须熟练掌握，都是基于AQS实现的，如果要深入了解源码可以阅读更多文章，这里主要介绍如何使用。 **CountDownLatch** 每次有线程调用 countDown() 数量-1，假设计数器变为0，countDownLatch.await() 就会被唤醒，继续执行！示例代码： ```java package CommonClassDemo;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ import java.util.concurrent.CountDownLatch; public class CountDownLatchDemo { public static void main(String[] args) throws InterruptedException { // 总数是6，必须要执行任务的时候，再使用！ CountDownLatch countDownLatch = new CountDownLatch(6); for (int i = 1; i <=6 ; i++) { new Thread(()->{ System.out.println(Thread.currentThread().getName()+" finished"); countDownLatch.countDown(); // 数量-1 },String.valueOf(i)).start(); } countDownLatch.await(); // 等待计数器归零，然后再向下执行 System.out.println("All Finished"); } } ``` 如果缺少该类的限制会怎么样？ > 会提前执行All Finished,与预期效果不符合注意：CountDownLatch 是一次性的，计数器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当 CountDownLatch 使用完毕后，它不能再次被使用。 **CyclicBarrier** > CountDownLatch的实现是基于AQS的，而CycliBarrier是基于 ReentrantLock(ReentrantLock也属于AQS同步器)和 Condition 的. CyclicBarrier 默认的构造方法是 `CyclicBarrier(int parties)`，其参数表示屏障拦截的线程数量，每个线程调用`await`方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞，直到数目达到`parties`才会执行。 ```java package CommonClassDemo;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class CyclicBarrierDemo { public static void main(String[] args) { /** * 执行7次，即可退出 */ CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{ System.out.println("退出成功！"); }); for (int i = 1; i <=7 ; i++) { final int temp = i; // lambda不能操作到 i，所以加一个final的temp new Thread(()->{ System.out.println("第"+Thread.currentThread().getName()+"线程执行完毕"); try { cyclicBarrier.await(); // 等待 } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } },String.valueOf(i)).start(); } } } ``` ### CyclicBarrier 和 CountDownLatch 的区别？ | CountDownLatch | CyclicBarrier | | :----------------------------------------------------------: | :----------------------------------------------------------: | | 减计数方式 | 加计数方式 | | 计算为0时释放所有等待的线程 | 计数达到指定值时释放所有等待线程 | | countDown()方法计数减一，会继续执行自己的任务。
await()方法只进行阻塞，不改变计数 | await()方法计数加1，如果未达到指定的数字则线程阻塞
所有线程任务结束之后，才会进行后续任务** | | 不可重复利用 | 可重复利用 | **Semaphore** 设置固定数目给线程进入执行，在 semaphore.acquire() 和 semaphore.release()之间的代码，同一时刻只允许制定个数的线程进入。 ```java package CommonClassDemo;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; public class SemaphoreDemo { public static void main(String[] args) { Semaphore semaphore = new Semaphore(3); for (int i = 1; i <=6 ; i++) { new Thread(()->{ // acquire() 得到 try { semaphore.acquire(); System.out.println(Thread.currentThread().getName()+" 进入"); TimeUnit.SECONDS.sleep(1); System.out.println(Thread.currentThread().getName()+" 离开"); } catch (InterruptedException e) { e.printStackTrace(); } finally { semaphore.release(); // release() 释放 } },String.valueOf(i)).start(); } } } ``` # 读写锁读写锁维护一对关联的锁，一个用于只读，一个用于写入。在同一时间内，允许多个线程同时读取，但是只允许一个线程写入。 ```java import java.util.HashMap; import java.util.HashSet; import java.util.concurrent.locks.ReentrantReadWriteLock; /*** * @author: G_night * 转载请声明作者 * Reprint please state the author ***/ public class ReadWriteLockDemo { public static void main(String[] args) { myRWLock myRWLock = new myRWLock(); for(int i=1;i<=10;i++){ final int t=i; new Thread(()->{ myRWLock.put(t,t); },"Write_Thread_"+String.valueOf(t)).start(); } for(int i=1;i<=10;i++){ final int t=i; new Thread(()->{ myRWLock.get(t); },"Read_Thread_"+String.valueOf(t)).start(); } } } class myRWLock{ //初始化读写锁 ReentrantReadWriteLock lock=new ReentrantReadWriteLock(); //存储数据的map HashMap map=new HashMap<>(); //存入 public void put(int k,int v){ lock.writeLock().lock(); try{ System.out.println(Thread.currentThread().getName()+"开始写入"); map.put(k,v); System.out.println(Thread.currentThread().getName()+"结束写入"); }finally { lock.writeLock().unlock(); } } public void get(int v){ lock.readLock().lock(); try{ System.out.println(Thread.currentThread().getName()+"开始读取"); System.out.println("获取："+map.get(v)); System.out.println(Thread.currentThread().getName()+"结束读取"); }finally { lock.readLock().unlock(); } } } ``` 运行结果：写入过程的操作不会有其他线程插队，而读取允许插队 # 阻塞队列&同步队列 **阻塞队列 **：当写满的时候继续写入会进入阻塞状态，当取东西时为空的时候也可以进入阻塞状态等待写入的东西。 | 方式 | 抛出异常 | 有返回值 | 阻塞等待 | 超时等待 | | -------- | -------- | -------- | --------- | -------- | | 添加 | add | offer | put | offer | | 移除 | remove | poll | take | poll | | 获取元素 | element | peek | \ | \ | 阻塞等待和超时等待的区别：阻塞等待会一直等，而超时等待可以自己设置等待的时间，若没有就不再等待。用法： `blockingQueue.poll ( 2 , TimeUnit.SECONDS ) ;` 第一个参数是数值，第二个是单位。 ```java import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.TimeUnit; public class BlockingQueueDemo { public static void main(String[] args) throws InterruptedException { // 队列的大小 ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3); blockingQueue.offer("a"); blockingQueue.offer("b"); blockingQueue.offer("c"); blockingQueue.offer("d",2, TimeUnit.SECONDS); // 等待超过2秒就退出， // 这时候如果有其他线程取出数值，那么阻塞就会提前结束 System.out.println(blockingQueue.poll()); System.out.println(blockingQueue.poll()); System.out.println(blockingQueue.poll()); blockingQueue.poll(2,TimeUnit.SECONDS); // 等待超过2秒就退出 } } ``` **同步队列**：类似阻塞队列，不同点在于没有容量，进去一个元素，必须等待取出来之后，才能再往里面放一个元素！主要的方法：put、take ```java import java.util.concurrent.BlockingQueue; import java.util.concurrent.SynchronousQueue; import java.util.concurrent.TimeUnit; public class SynchronousQueueDemo { public static void main(String[] args) { BlockingQueue queue=new SynchronousQueue<>(); new Thread(()->{ try { System.out.println("put : a"); queue.put("a"); System.out.println("put : b"); queue.put("b"); System.out.println("put : c"); queue.put("c"); } catch (InterruptedException e) { e.printStackTrace(); } },"1").start(); new Thread(()->{ try { TimeUnit.SECONDS.sleep(2); System.out.println("take : "+queue.take()); TimeUnit.SECONDS.sleep(2); System.out.println("take : "+queue.take()); TimeUnit.SECONDS.sleep(2); System.out.println("take : "+queue.take()); } catch (InterruptedException e) { e.printStackTrace(); } },"2").start(); } } ``` 运行结果：每次put后都在等待take以后继续put。 ```bash put : a take : a put : b take : b put : c take : c ``` # 线程池好处： 1. 提高响应速度（减少创建时间） 2. 降低资源消耗（可重用） 3. 便于线程管理 **ExecutorService** ExecutorService是线程池的接口，实现类为ThreadPoolExecutor，Executors是线程池创建的工具类步骤： 1. 使用Executors工具类创建线程池，返回ThreadPoolExecutor 2. 设置线程池所需参数 3. 调用ThreadPoolExecutor类执行方法 --> execute、submit等 **线程池的常用方法：** Executors工具类（创造线程池）的常用方法： ```java newCacheThreadPool() //根据需求创造线程池（依据所需线程数量，默认创建数目可以很大） newFIxedThreadPool() //可重用的固定线程池（常用方法） newSingleThreadExecutor() //单个线程的线程池 newScheduledThreadPool() //创建一个线程池。在给定安排的延迟后执行 ``` ThreadPoolExecutor（线程池）的常用方法： ```java executoe() //传入实现Runnable接口的实例 submit() //传入实现Callable or Runnable接口的实例 /* submit() 一般是传入实现Callable接口的实例然后用FutureTask类接收返回值 */ shutdown() //关闭线程池 ``` 设置线程池参数！ ```java corePoolSize() //核心线程数目 maximumPoolSize() //最大线程数 keepAliveTime() //线程无任务时，最多保持多长时间后终止 ``` > 核心线程数目和最大线程数有什么区别？ > > 核心线程数主要是**初始化固定数目的线程数**，而当线程需要很多的时候，一旦等候区也满了，那么就会继续开辟新的线程，此时线程数目也不会超过**最大线程数**。 > > 新开辟的非核心线程，在没有任务的固定时间后就会关闭终止！示例： ```java package com.zzt;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; /** * 线程池的使用示例 **/ class myRunnable implements Runnable{ @Override public void run(){ System.out.println("执行完成"); } } public class MyThreadPool { public static void main(String[] args) { // 1. 使用工具类初始化线程池 ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newFixedThreadPool(10); // 2. 实例化实现Runnable接口的对象 myRunnable myRunnable = new myRunnable(); // 3. 执行线程 service.execute(myRunnable); // 4. 关闭线程池 service.shutdown(); } } ``` ### 实际开发线程池的用法 Executors实际上都是使用ThreadPoolExecutor来创建线程！ **实际开发中，我们不会直接使用Executors来创建线程**！我们可以进入`Executors.newCachedThreadPool()`中`newCachedThreadPool`方法可以看到： ```java public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue()); } ``` 设置的最大线程数太大了，不适合实际开发，会出现资源耗尽的风险。所以我们要自己使用`ThreadPoolExecutor`创建线程池详解：ThreadPoolExecutor ```java public ThreadPoolExecutor(int corePoolSize, //核心线程数 int maximumPoolSize, //最大线程数目 long keepAliveTime, //线程无任务，保持最长时间 TimeUnit unit, //时间单位 BlockingQueue workQueue,//阻塞队列，等候区大小 ThreadFactory threadFactory,//创建工程，一般不改！ RejectedExecutionHandler handler) {//拒绝策略 if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0) throw new IllegalArgumentException(); //不符合设置规则 if (workQueue == null || threadFactory == null || handler == null) throw new NullPointerException();//缺少阻塞队列（等候区）、工厂、拒绝策略 this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; } ``` **创建线程池模板** ```java import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class ThreadPoolDemo { public static void main(String[] args) { int cpu = Runtime.getRuntime().availableProcessors();//获取可使用的cpu核数 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, cpu, 4, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3),//等待3区大小 Executors.defaultThreadFactory()); try{ for(int i=1;i<=20;i++){ threadPoolExecutor.execute(()->{ System.out.println(Thread.currentThread().getName()+" finished"); }); } }finally { threadPoolExecutor.shutdown(); } } } ``` **拒绝策略** 默认的拒绝策略是会抛出错误的，下面介绍四种拒绝策略 ```java new ThreadPoolExecutor.AbortPolicy() // 队列满了后抛出异常 new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的就回哪去！比如主线程来的，那就回主线程执行 new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！ new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和早的竞争，不会抛出异常！ ``` **思考** 如何设置线程的最大数目？ > 1. 当cpu密集型的时候，通过Runtime.getRuntime().availableProcessors()获取最大核数，来设置最大线程数 > 2. 当IO密集型，由于IO执行很慢，所以需要不断轮换切换，故设置的线程数，最好是大型IO数的两倍左右。 # ForkJoin ForkJoin 在 JDK 1.7 ，并行执行任务！提高效率。大数据量！有点类似动态规划的思想，就是把大任务分成很多小任务实现。 > ForkJoin 特点：工作窃取，维护的都是双端队列 ForkJoinTask的编写，首先继承父类，实现子类的方法（这里以RecursiveTask为例）。判断是否小于临界值，如果小于那么就直接返回值，如果大于就创建两个新任务，加入执行 ```java package ForkjoinDemo;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ import java.util.concurrent.RecursiveTask; public class forkDemo extends RecursiveTask { private Long start; private Long end; // 临界值 private Long temp = 10000L; public forkDemo(Long start, Long end) { this.start = start; this.end = end; } // 计算方法 @Override protected Long compute() { if ((end-start) task = new forkDemo(0L, 100000000L); ForkJoinTask submit = forkJoinPool.submit(task); Long aLong = submit.get(); System.out.println(aLong); } } ``` # 异步回调使用`Future`获得异步执行结果时，要么调用阻塞方法`get()`，要么轮询看`isDone()`是否为`true`，这两种方法都不是很好，因为主线程也会被迫等待。从Java 8开始引入了`CompletableFuture`，它针对`Future`做了改进，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。 **重要的方法介绍** ### 1、runAsync & supplyAsync CompletableFuture 提供了四个静态方法来创建一个异步操作。 ```java public static CompletableFuture runAsync(Runnable runnable) public static CompletableFuture runAsync(Runnable runnable, Executor executor) public static CompletableFuture supplyAsync(Supplier supplier) public static CompletableFuture supplyAsync(Supplier supplier, Executor executor) ``` 没有指定Executor的方法会使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池，则使用指定的线程池运行。以下所有的方法都类同。 - runAsync方法不支持返回值。 - supplyAsync可以支持返回值。 ```java //无返回值 public static void runAsync() throws Exception { CompletableFuture future = CompletableFuture.runAsync(() -> { System.out.println("running"); }); future.get();//获取阻塞执行结果 } //有返回值 public static void supplyAsync() throws Exception { CompletableFuture future = CompletableFuture.supplyAsync(() -> { try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { } return 100L; }); Long result = future.whenComplete((t, u) -> { System.out.println("ok--> "+t);//返回正确执行的结果 System.out.println("no--> "+u);//输出错误信息 }).exceptionally((e) -> { e.printStackTrace(); return 200L;//错误执行时的返回结果 }).get(); System.out.println("result = "+result); } ``` ### 2、thenApply 方法当一个线程依赖另一个线程时，可以使用 thenApply 方法来把这两个线程串行化。该方法出现错误地的时候不会执行！ ```java public CompletableFuture thenApply(Function fn) public CompletableFuture thenApplyAsync(Function fn) public CompletableFuture thenApplyAsync(Function fn, Executor executor) ``` Function T：上一个任务返回结果的类型 U：当前任务的返回值类型 **示例** ```java private static void thenApply() throws Exception { CompletableFuture future = CompletableFuture.supplyAsync(()->{//supplier long result = new Random().nextInt(100); System.out.println("result1="+result); return result; }).thenApply((t)->{//function，传入一个参数返回一个结果！ long result = t*5; System.out.println("result2="+result); return result; }); long result = future.get(); System.out.println(result); } ``` ### 3、handle 方法 handle 是执行任务完成时对结果的处理。 handle 方法和 thenApply 方法处理方式基本一样。不同的是 handle 是在任务完成后再执行，还可以处理异常的任务。thenApply 只可以执行正常的任务，任务出现异常则不执行 thenApply 方法。 ```java public CompletionStage handle(BiFunction fn); public CompletionStage handleAsync(BiFunction fn); public CompletionStage handleAsync(BiFunction fn,Executor executor); ``` **示例** ```java public static void handle() throws Exception{ CompletableFuture future = CompletableFuture.supplyAsync(()->{ int i= 10/0; return new Random().nextInt(10); }).handle(new BiFunction() { @Override public Integer apply(Integer param, Throwable throwable) { int result = -1; if(throwable==null){ result = param * 2; }else{ System.out.println(throwable.getMessage()); } return result; } }); System.out.println(future.get()); } ``` 从示例中可以看出，在 handle 中可以根据任务是否有异常来进行做相应的后续处理操作。而 thenApply 方法，如果上个任务出现错误，则不会执行 thenApply 方法。 ### 4、thenCombine 合并任务 thenCombine 会把两个 CompletionStage 的任务都执行完成后，把两个任务的结果一块交给 thenCombine 来处理。 ```java public CompletionStage thenCombine(CompletionStage other,BiFunction fn); public CompletionStage thenCombineAsync(CompletionStage other,BiFunction fn); public CompletionStage thenCombineAsync(CompletionStage other,BiFunction fn,Executor executor); ``` **示例** ```java private static void thenCombine() throws Exception { CompletableFuture future1 = CompletableFuture.supplyAsync(()->{ return "hello"; }); CompletableFuture future2 = CompletableFuture.supplyAsync(()->{ return "hello"; }); CompletableFuture result = future1.thenCombine(future2, (t,u)->{ return t+" "+u; }); System.out.println(result.get()); } ``` # Volatile 学习Volatile要先了解一下JMM，理解java内存的操作 ### JMM > Java内存模型，不存在的东西，是一种约定！ > > JMM的三大特点：可见性、原子性、有序性 > > 在JVM中运行的程序实体是线程，线程被创建的时候会被分配一个`工作内存`（有些地方为栈空间），工作内存是每个线程的私有数据域，而java内存内存模型规定所有变量都在主内存，主内存为共享内存区域，所有线程都可以访问。 > > 线程对变量的操作（读取写入）必须在工作内存中运行。 > > 大概步骤： > > 1. 把主内存数据拷贝到工作内存 > 2. 对变量进行操作 > 3. 将变量写回主内存 Java内存模型中定义了8种操作来完成，虚拟机保证了每种操作都是原子的。 - lock（锁定）：作用于主存的变量，把一个变量标识为一条线程独占状态。 - unlock（解锁）：作用于主存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。 - read（读取）：作用于主存变量，把一个变量的值从主存传输到工作内存。 - load（载入）：作用于工作内存变量，把 read 来的值放入工作内存的变量副本中。 - use（使用）：作用于工作内存变量，把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。 - store（存储）：作用于工作内存变量，把工作内存中一个变量的值传送到主存。 - write（写入）：作用于主存变量，把 store 操作从工作内存中得到的变量的值放入主存的变量中。在将变量从主内存读取到工作内存中，必须顺序执行read、load；要将变量从工作内存同步回主内存中，必须顺序执行store、write。并且这8种操作必须遵循以下规则： - 1，不允许read和load、store和write操作之一单独出现。即不允许一个变量从主内存被读取了，但是工作内存不接受，或者从工作内存回写了但是主内存不接受。 - 2，不允许一个线程丢弃它最近的一个assign操作，即变量在工作内存被更改后必须同步改更改回主内存。 - 3，工作内存中的变量在没有执行过assign操作时，不允许无意义的同步回主内存。 - 4，在执行use前必须已执行load，在执行store前必须已执行assign。 - 5，一个变量在同一时刻只允许一个线程对其执行lock操作，一个线程可以对同一个变量执行多次lock，但必须执行相同次数的unlock操作才可解锁。 - 6，一个线程在lock一个变量的时候，将会清空工作内存中的此变量的值，执行引擎在use前必须重新read和load。 - 7，线程不允许unlock其他线程的lock操作。并且unlock操作必须是在本线程的lock操作之后。 - 8，在执行unlock之前，必须首先执行了store和write操作。 ### Volatile的作用 > Volatile 是 Java 虚拟机提供轻量级的同步机制 > > 1. 保证可见性 > 2. 不保证原子性 > 3. 禁止指令重排 ( 由于内存屏障，可以保证避免指令重排的现象产生！ ) #### 1. 可见性 ```java package VolatileDemoPackage; import java.util.concurrent.TimeUnit; public class VolatileDemo { public static void main(String[] args) { VolatileNum num=new VolatileNum(0); new Thread(()->{ while(num.getNum()==0){ //由于不可见性，所以会一直不结束！ //System.out.println("show:"+num.getNum()); //如果加了sout就可以见了，会自动结束！ /*因为System.out.println: public void println(String x) { synchronized (this) { print(x); newLine(); } } */ } }).start(); try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } num.setNum(1); System.out.println(num.getNum()); } } class VolatileNum{ private volatile int num; public VolatileNum(int num) { this.num = num; } public int getNum() { return num; } public synchronized void setNum(int num) { this.num = num; } } ``` #### 2. 不保证原子性如果不加锁，那么输出结果会和预期有偏差，原因num++操作实际上不止一步（num++操作不具有原子性），途中被插入就会导致结果错误。解决方式：加锁或采用原子变量（ Atomic~）操作 ```java package VolatileDemoPackage;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; public class yuanzixing { /* 方法一：加锁实现原子性，不过效率低 */ public static volatile int num1=0; public static synchronized void add1(){ num1++; } //原子变量！ public static AtomicInteger num2=new AtomicInteger(0); public static void add2(){ num2.getAndIncrement(); } public static void main(String[] args) { for(int i=0;i<10;i++){ new Thread(()->{ for(int j=0;j<2000;j++){ add1(); } }).start(); new Thread(()->{ for(int j=0;j<2000;j++){ add2(); } }).start(); } while(Thread.activeCount()>2){ }//默认main、gc线程， // 意思是等那十个线程都执行完了！再输出 System.out.println("num1 = "+num1); System.out.println("num2 = "+num2); } } ``` 那么原子变量是怎么保证原子性的呢？ ```java public final int getAndIncrement() { return unsafe.getAndAddInt(this, valueOffset, 1); // 参数介绍 // 第一个：当前对象 // 第二个：当前对象内存地址偏移值 } ``` CAS的核心类是：unsafe，java方法无法直接访问底层，需要通过本地（native）方法来实现对底层的访问，相当于一个后门，可以直接操控特定的内存数据。unsafe是通过偏移地址（valueOffset）获取数值的，故CAS是通过硬件功能，由若干个指令完成，并且能保证执行是连续的，保证了操作的原子性。 #### 3. 禁止指令重排指令重排是指jvm或操作系统为了提高效率，对指令的执行顺序的调整。（系统会考虑依赖程度，进行调整）例子： ```java int a=1; //1 int b=1; //2 a = a+1; //3 b = a*a; //4 ``` 执行顺序为：1，2，3，4 实际可能执行顺序为：2，1，3，4 ```markdown # 假设有两条线程，初始化a,b,x,y都为0 第一条：x=a,b=1 第二条：y=b,a=1 ## 执行结果：预期： x=0,y=0,a=1,b=1 可能会出现： x=1,y=1,a=1,b=1 #### 指令重排的后果就出现了 ``` 可是加了volatile后不会出现指令重排，可以正常实现预期效果。内存屏障的作用：禁止上面和下面的指令交换顺序 #### 4. volatile与synchronized的区别 - volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。 - volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的 - volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性 - volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。 - volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化 # 单例模式 > 单例模式就是在程序运行中只实例化一次，创建一个全局唯一对象，有点像 Java 的静态变量，但是单例模式要优于静态变量，静态变量在程序启动的时候JVM就会进行加载，如果不使用，会造成大量的资源浪费，单例模式能够实现懒加载，能够在使用实例的时候才去创建实例。开发工具类库中的很多工具类都应用了单例模式。 **单例的实现思路** - 静态化实例对象 - 私有化构造方法，禁止通过构造方法创建实例 - 提供一个公共的静态方法，用来返回唯一实例 **单例的好处** - 只有一个对象，内存开支少、性能好 - 在系统设置全局访问点，优化和共享资源访问 ### 普通的单例模式 1. 饿汉式（线程安全的） ```java public class X{ private static X a=new X(); private X(){} public static X getInstance(){ return a; } } ``` 2. 懒汉式（线程不安全，所以要加synchronized变成线程安全，采用双重校验锁） ```java public class X{ private static X a; private X(){} private static Object key = new Obejct(); public static X getInstance(){ if(a == null){//提高效率 synchronized (key) {//线程安全模式 if(a==null){ a = new X(); } } } return a; } } ``` 然而这些都可以通过反射创建新的实例，存在漏洞。 ```java package SingleDemoPackage;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ import java.lang.reflect.Constructor; public class SingleDemo { public static void main(String[] args) throws Exception { X a=X.getInstance(); Constructor constructor = a.getClass().getDeclaredConstructor(null); constructor.setAccessible(true); X b = (X) constructor.newInstance(); X c=X.getInstance(); System.out.println(a==b);//使用反射创建的对象是新对象，输出：false System.out.println(a==c);//getInstance为同一对象，输出：true } } ``` ### 静态内部类单例模式静态内部类单例模式也称单例持有者模式，实例由内部类创建，由于 JVM 在加载外部类的过程中, 是**不会加载静态内部类**的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由`static`修饰，保证只被实例化一次，并且严格保证实例化顺序。静态内部类单例模式代码如下： ```java public class SingletonDemo { private SingletonDemo(){} // 单例持有者 private static class InstanceHolder{ private final static SingletonObject6 instance = new SingletonObject6(); } public static SingletonDemo getInstance(){ // 调用内部类属性 return InstanceHolder.instance; } } ``` 静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。 ### 枚举类单例模式枚举类介绍： - 枚举只能拥有私有的构造器 - 枚举类不允许被反序列化，Enum重写了方法 - 静态代码块中对final变量的值进行初始化 - enum类最终是一个final class 因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中**唯一一种**不会被破坏的单例实现模式。 **所以强烈推荐使用这个方式实现单例模式！** ```java package SingleDemoPackage;/* * @author: G_night * 转载请申明作者 * Reprint please state the author */ public enum Singleton { INSTANCE; private String instance; Singleton(){ instance = new String("hello"); } public String getInstance(){ return instance; } } ``` # 后记这只是开始，并不是结束~ 提供本次参考的`代码`及`markdown文档`：https://gitee.com/g_night/JucStudy/tree/master 里面的代码不完全和上面示例的相同，仅是个人在验证想法过程中顺带写的。