JUC 并发编程学习

JUC 并发编程学习笔记

学习过程观看视频：[狂神说Java]
https://www.bilibili.com/video/BV1B7411L7tE?p=13

1.并发编程包

java.util.concurrent

普通的线程代码 Thread

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

Callable 、Lock、ReentrantLocl\ReentrantReadWriteLock.ReadLock

2.线程和进程是什么？

一个进程往往可以包含多个线程，至少包含一个！
Java默认有几个线程？ 2 个 mian、GC
线程：开了一个进程 Typora，写字，自动保存（线程负责的）

对于Java而言开启线程的方式：Thread、Runnable、Callable、以及线程池

JAVA无法直接开启线程，查看底层代码Thread.start()下。可以看到开启线程只是将当前线程加入一个线程组然后调用底层c++的start0（）开启线程。

线程的状态有那些：可以查看Thead.State 查看有 6种。jdk1.5设置的

1.创建 new

2.运行 RUNNABLE

3.BLOCKED 阻塞

4.WAITING 等待

5.TIMED_WAITING 超时等待

6.TERMINATED 销毁

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

3.juc下的Locks学习

传统的同步代码块是由synchronized修饰

synchronized的本质是什么？

synchronized是队列加锁

Lock是什么？

是juc下的一个接口，实现类有

ReentrantLock、ReentrantReadWriteLock.ReadLock

ReentrantLock是重复锁。并且构造函数可以设置公平还是非公平

使用Lock

Lock lock= new ReentrantLock();//new 一个Lock实例对象

lock.lock();//加锁

lock.unlock();//解锁

Lock和synchronized的区别

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

锁是什么?如何判断锁？

8锁问题：

两个方法持有一把锁，谁先拿到谁执行

如果方法没有同步锁，无需执行锁的规则逻辑

如果两个方法持有锁不同，互相不影响

static + synchronized 锁的是当前类对象.class

---

new this 具体的一个手机

static Class 唯一的一个模板

---

package com.kuang.demo06;
//基本的卖票例子
/**
* 真正的多线程开发，公司中的开发，降低耦合性
*线程就是一个单独的资源类，没有任何附属的操作
* 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);
       }
   }
   //锁 锁的是对象
   //锁class

}

生产者与消费者synchronized实现

package com.kuang.productorcous;
/**
 *线程之间的通信问题：生产者和消费者问题！等待唤醒，通知唤醒
 * 线程交替执行 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){//0的时候干活
            //等待操作
            this.wait();

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

        }number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

上面程序不能使用if，使用if会产生虚假唤醒。改为while解决。

Condition 是什么？怎么使用？

​ Condition condition = lock.newCondition();

​ condition.signalAll();=Object.notify(); 替换

​ condition.await(); = Object.wait();替换

 package com.kuang.productorcous;

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

public class B {
    public static void main(String[] args) {
        //创建一个资源类
        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) {
                    //0的时候干活
                    condition.await();
                }
                number++;
                System.out.println(Thread.currentThread().getName() + "=>" + number);
                //通知其他线程，我-1完毕了
               condition.signalAll();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();

            }

        }


        public  void decrement() throws InterruptedException {
            lock.lock();
            try{
                while (number == 0) {//1的时候干活
                    //等待
                    condition.await();


                }
                number--;
                System.out.println(Thread.currentThread().getName() + "=>" + number);
                //通知其他线程，我-1完毕了
                condition.signalAll();

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

        }
    }

Condition 精准的通知和唤醒线程

创建多个监听

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

然后一次等待和唤醒如 1好了唤醒2，2好了唤醒3，3好了唤醒1

while (number!=1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAA");
            //唤醒，唤醒指定的人B
            number = 2;
            condition2.signal();

ReentrantLock是什么？

就是一对的Lock ，一个专门用来写一个专门用来读

写锁write 是独占锁，只能有一个线程持有

读锁read是共享锁，所有人都可以持有

读-读 可以

读-写 互斥

写-写 互斥

适用于多读少写的环境

4.线程池

1.Executors工具类的不同方法按照我们的需求创建了不同的线程池，来满足业务的需求。
2.Executor 接口对象能执行我们的线程任务。
3.ExecutorService接口继承了Executor接口并进行了扩展，提供了更多的方法获取任务执行的状态并可以获取任务的返回值。
4.使用ThreadPoolExecutor可以创建自定义线程池。
5.Future表示异步计算的结果，他提供了检查计算是否完成的方法，可以使用get()方法获取计算的结果。

4.1线程池的三大方法

ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线
程
// ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一
个固定的线程池的大小
// ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩
的，遇强则强，遇弱则弱

本质都是调用new ThreadPoolExecutor（）完成线程池构建；

4.2 线程池的7大参数

int corePoolSize, // 核心线程池大小                         
int maximumPoolSize, // 线程池最大容量 （CPU密集型：Runtime.getRuntime().availableProcessors();获取当前运行环境的最大线程数）   
Io密集型设置任务数的2倍
long keepAliveTime, // 超时了没有人调用就会释放                          
TimeUnit unit, // 超时单位                         
BlockingQueue<Runnable> workQueue, // 阻塞队列                          
ThreadFactory threadFactory, // 线程工厂：创建线程的，一般不用动                          
RejectedExecutionHandler handle // 拒绝策略) 

4.3四种拒绝策略

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

工作流程：
1 当一个任务通过submit或者execute方法提交到线程池的时候，如果当前池中线程数（包括闲置线程）小于coolPoolSize，则创建一个线程执行该任务。

2 如果当前线程池中线程数已经达到coolPoolSize，则将任务放入等待队列。

3 如果任务不能入队，说明等待队列已满，若当前池中线程数小于maximumPoolSize，则创建一个临时线程（非核心线程）执行该任务。

4 如果当前池中线程数已经等于maximumPoolSize，此时无法执行该任务，根据拒绝执行策略处理。

5.集合类

1.CopyOnWriteArrayList

1.ArrayList是线程不安全的，多线程下使用会导致并发修改异常

解决方案：1、使用Vector，Vector就是add上加了synchronized代码同步块。缺点是效率低下。

2、使用Collection.synchronizedList(new ArrayList())函数生成。

3.使用JUC的copyreadwritrarraylist

在****CopyOnWriteArrayList*里处理写操作（包括add、remove、set等）是*先将原始的数据通过JDK1.6的Arrays.copyof()来生成一份新的数组****，***然后**在新的数据对象上进行写，写完后再将原来的引用指向到当前这个数据对象（这里应用了常识1），这样保证了每次写都是在新的对象上***（因为要保证写的一致性，这里要对各种写操作要加一把锁，JDK1.6在这里用了重入锁），然后读的时候就是在引用的当前对象上进行读（包括get，iterator等）

CopyOnWriteArrayList中写操作需要大面积复制数组，所以性能肯定很差，但是读操作因为操作的对象和写操作不是同一个对象，读之间也不需要加锁，读和写之间的同步处理只是在写完后通过一个简单的“=”将引用指向新的数组对象上来，这个几乎不需要时间，这样读操作就很快很安全，适合在多线程里使用，绝对不会发生ConcurrentModificationException，所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。

缺点：

内存占用问题。

因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意:在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）。如果这些对象占用的内存比较大，比如说200M左右，那么再写入100M数据进去，内存就会占用300M，那么这个时候很有可能造成频繁的Yong GC和Full GC。之前我们系统中使用了一个服务由于每晚使用CopyOnWrite机制更新大对象，造成了每晚15秒的Full GC，应用响应时间也随之变长。

数据一致性问题。

CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

2.copyonWritrArraySet

set底层实现是hashmap,不可重复元素就是因为map的key是不可重复的。

为Put（v,Object）;

3.concurrenthashmap

1. HashMap不是线程安全：

在并发环境下，可能会形成环状链表（扩容时可能造成，具体原因自行百度google或查看源码分析），导致get操作时，cpu空转，所以，在并发环境中使用HashMap是非常危险的

2. HashTable是线程安全的：

HashTable和HashMap的实现原理几乎一样，
差别：

1.HashTable不允许key和value为null；
2.HashTable是线程安全的。
HashTable线程安全的策略实现代价却比较大，get/put所有相关操作都是synchronized的，这相当于给整个哈希表加了一把大锁，多线程访问时候，只要有一个线程访问或操作该对象，那其他线程只能阻塞

3. ConcurrentHashMap是线程安全的：

JDK1.7版本： 容器中有多把锁，每一把锁锁一段数据，这样在多线程访问时不同段的数据时，就不会存在锁竞争了，这 样便可以有效地提高并发效率。这就是ConcurrentHashMap所采用的"分段锁"思想

JDK1.8版本：

1.直接采用transient volatile HashEntry<K,V>[] table保存数据，采用table数组元素作为锁，从而实现了对每一行数据进行加锁，并发控制使用Synchronized和CAS来操作

2.将原先table数组＋单向链表的数据结构，变更为table数组＋单向链表＋红黑树的结构.（跟hashmap一样，在元素大于64时转换）

hashmap底层原理

在ConcurrentHashMap中通过一个Node<K,V>[]数组来保存添加到map中的键值对，而在同一个数组位置是通过链表和红黑树的形式来保存的。但是这个数组只有在第一次添加元素的时候才会初始化，否则只是初始化一个ConcurrentHashMap对象的话，只是设定了一个sizeCtl变量，这个变量用来判断对象的一些状态和是否需要扩容，后面会详细解释。
第一次添加元素的时候，默认初期长度为16，当往map中继续添加元素的时候，通过hash值跟数组长度取与来决定放在数组的哪个位置，如果出现放在同一个位置的时候，优先以链表的形式存放，在同一个位置的个数又达到了8个以上，如果数组的长度还小于64的时候，则会扩容数组。如果数组的长度大于等于64了的话，在会将该节点的链表转换成树。

通过扩容数组的方式来把这些节点给分散开。然后将这些元素复制到扩容后的新的数组中，同一个链表中的元素通过hash值的数组长度位来区分，是还是放在原来的位置还是放到扩容的长度的相同位置去 。在扩容完成之后，如果某个节点的是树，同时现在该节点的个数又小于等于6个了，则会将该树转为链表。

取元素的时候，相对来说比较简单，通过计算hash来确定该元素在数组的哪个位置，然后在通过遍历链表或树来判断key和key的hash，取出value值。

6.Callable和runnable（需补充）

Callable的实现类要怎么调用呢？

使用适配器FutureTask ，FutureTask 是RunnAble实现类

new Thread( FutureTask Callable).start();

细节：

1.有缓存

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

7.三大常用辅助类

1.countDownLatch

计数器

countDownLatch.down();//减一

countDownLatch.await()；//要等待上面减数执行完毕才会执行

2.CyclicBarrier

会计数，当等待线程达到目标数，触发设置好的线程

集齐所有条件后继续执行

3.Semaphore(信号量)

主要用来限流，使多线程执行有顺序

Semaphore s = new Semapphore(int 1);//线程数量
s.acquire();获取资源
s.release();释放资源

8.阻塞队列 BlockingQueue 的四组api

第一组 add() 和 remove() 方法

// 抛出异常 返回布尔值
    public static void test1(){
        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(3);
        System.out.println(queue.add(1));
        System.out.println(queue.add(2));
        System.out.println(queue.add(3));
        // 抛出异常 java.lang.IllegalStateException: Queue full
        // System.out.println(queue.add(4));
        System.out.println(queue.remove());
        System.out.println(queue.remove());
        System.out.println(queue.remove());
        // 抛出异常 java.util.NoSuchElementException
        // System.out.println(queue.remove());
    }

add方法在阻塞队列中添加元素会返回布尔值，如果阻塞队列满了还在继续添加就会抛出异常，队列每次remove会弹出阻塞队列队首元素，并且返回改弹出元素，如果阻塞队列为空继续remove就会抛出异常

第二组 offer() 和 poll() 方法（无参版）

public static void test2(){
        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(3);
        System.out.println(queue.offer(1));
        System.out.println(queue.offer(2));
        System.out.println(queue.offer(3));
        // 不抛出异常，返回布尔值
        System.out.println(queue.offer(4));
        // 检测队首元素 如果队列为空抛出异常
        //System.out.println(queue.element());
        // 检测队首元素， 如果队列为空返回null
        System.out.println(queue.peek());

        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        // 不抛出异常， 返回null
        System.out.println(queue.poll());
        // 抛出异常java.util.NoSuchElementException
        //System.out.println(queue.element());
        // 如果队首没有元素返回null 不抛出异常
        System.out.println(queue.peek());
    }

offer() 和 poll()方法在阻塞队列为满或者空时返回布尔值（成功返回true，失败返回false），不会抛出异常。这里附加两个检查队首元素的方法。element()检查队首元素，如果队列为空抛出异常；peek()检测队首元素， 如果队列为空返回null，不抛出异常。

第三组 put() 和 take() 方法

// 等待 阻塞，一直阻塞 没有返回值
    public static void test3() throws InterruptedException {
        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(2);
        queue.put(1);
        queue.put(2);
        // 阻塞
        //queue.put(3);
        System.out.println(queue.take());
        System.out.println(queue.take());
        // 阻塞 等待
        // queue.take();
    }

put() 和 take() 方法会在队列满或空时一直阻塞等待，直到队列不为满或空时。put()方法没有返回值。

第四组 offer() 和 poll() 方法（带参版）

public static void test4() throws InterruptedException {
        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(2);
        queue.offer(1);
        queue.offer(2);
        // 阻塞等待2s，
        queue.offer(3, 2, TimeUnit.SECONDS);
        System.out.println("==================");
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        queue.poll(3, TimeUnit.SECONDS);
        System.out.println("==================");
    }

offer() 方法带参数，第一个参数是往队列中添加的元素，第二个参数是时间大小，第三个单位是时间单位（使用TimeUnit工具类）
poll()中第一个参数是时间大小，第二个单位是时间单位（使用TimeUnit工具类）
offer() 和 poll() 方法没有返回值，会设置等待时间，超过等待时间之后就继续执行之后的语句。

9.四个底层接口

1.函数型接口 Function

package com.function;

import java.util.function.Function;

/**
 * Created by zjl
 * 2020/11/25
 **/

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

        //方式二，使用lambda表达式简化的
        Function<String,String> function1 = (str)->{return str;};
        System.out.println(function1.apply("def"));
    }

}

有传入有传出常用于匿名内部类等。

2.Predicate 断定型接口

package com.function;

import java.util.function.Predicate;

/**
 * Created by zjl
 * 2020/11/25
 **/
/*** 断定型接口：有一个输入参数，返回值只能是 布尔值！ */
public class Demo02 {
    public static void main(String[] args) {
        // 方式一
        // 判断字符串是否为空
        Predicate<String> stringPredicate = new Predicate<String>() {
            @Override
            public boolean test(String str) {
                return str.isEmpty();
            }
        };
        System.out.println(stringPredicate.test("abc"));

        //方式二  使用lambda表达式简化
        Predicate<String> predicate = (str)->{return str.isEmpty();};
        System.out.println(predicate.test("bcd"));
    }
}

有传入参数返回boolean ，常用于用于判断。如steam流函数里的filter

3.消费者接口Consumer

package com.function;

/**
 * Created by zjl
 * 2020/11/25
 **/

import java.util.function.Consumer;

/*** Consumer 消费型接口: 只有输入，没有返回值 */
public class Demo03 {

    public static void main(String[] args) {
        //方式一
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };
        consumer.accept("abc");


        //方式二
        Consumer<String> consumer1 = (str2)->{System.out.println(str2);};
        consumer1.accept("bcd");

    }
}

只有传入没有返回，消费者与生产者概念中的消费者。目前工作中都是自己写并没有调用这个接口

4.生产者接口Supplier

package com.function;

import java.util.function.Supplier;

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



//        方式二
        Supplier supplier1 = ()->{return 1024;};
        System.out.println(supplier1.get());
    }

}

只有返回没有传入

10.Stream流编程

参考JDK8手册或者https://www.cnblogs.com/hmy-1365/p/12923435.html

11.ForkJoin

将大任务转为小任务。并且递归操作，最后将结果统一返回

package com.function;

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

/**
 * Created by zjl
 * 2020/11/29
 **/
public class ForkJoinDemoTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        test1();
    }

    //常规求和方式
    public static void test1(){
        Long sum = 0L;
        Long startTime = System.currentTimeMillis();
        for (int i = 0; i <= 10_0000_0000; i++) {
            sum += i;
        }
        System.out.println(sum);
        long endTime = System.currentTimeMillis();
        System.out.println("运行时间" + (endTime/1000 - startTime/1000) + "秒");
    }

    //使用ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
        long startTime = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinDemo forkJoinDemo = new ForkJoinDemo(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(forkJoinDemo);   //提交任务

        Long sum = submit.get();
        System.out.println(sum);
        long endTime = System.currentTimeMillis();
        System.out.println("运行时间" + (endTime/1000 - startTime/1000) + "秒");
    }

    public static void test3(){
        long startTime = System.currentTimeMillis();
        // parallel()并行执行，Long::sum就是（l1,l2）->{return Long.sum(l1,l2)}
        //reduce方法用于对stream中元素进行聚合求值，最常见的用法就是将stream中一连串的值合成为单个值，比如为一个包含一系列数值的数组求和
        long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
        System.out.println(sum);
        long endTime = System.currentTimeMillis();
        System.out.println("运行时间" + (endTime/1000 - startTime/1000) + "秒");

    }
}

使用了3种计算方式，常规的、forkJoin、Stream。

12.CompletableFuture

异步回调任务。

这个completableFuture是JDK1.8版本新引入的类。下面是这个类。实现了俩接口。本身是个class。这个是Future的实现类。

使用completionStage接口去支持完成时触发的函数和操作。

一个completetableFuture就代表了一个任务。他能用Future的方法。还能做一些之前说的executorService配合futures做不了的。

之前future需要等待isDone为true才能知道任务跑完了。或者就是用get方法调用的时候会出现阻塞。而使用completableFuture的使用就可以用then，when等等操作来防止以上的阻塞和轮询isDone的现象出现。

CompletableFuture的使用

CompletableFuture completableFuture = CompletableFuture.supplyAsync( Runnable b);

使用whenComplete（）获取成功后的内容，2个泛型内容。

第一个是return的内容；

第二个可以打印错误信息

使用exceptionally（）设置错误编码和报错信息。

/**
 * 异步调用: CompletableFuture
 * 异步执行
 * 成功回调
 * 失败回调
 */
public class Demo01 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 发起一个请求

//        CompletableFuture future = CompletableFuture.runAsync(()->{
//            System.out.println("发送一个没有返回值的异步请求");
//        });
//
//        System.out.println("1111");
//
//        future.get(); //获取执行结果

        //callable就可以实现异步调用,为什么要使用CompletableFuture呢,
        //CompletableFuture更加强大, callable只有成功回调
        //CompletableFuture可以有成功回调,异常(失败)回调
//        ExecutorService service = Executors.newCachedThreadPool();
//        Future<?> submit = service.submit(() -> {
//            System.out.println("这个是callable实现的异步调用,异步是目的,多线程是实现方式!!!");
//        });
//        System.out.println("1111");
//        submit.get();   //获取执行结果


        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("供应型接口");
            return 1024;
        });

        //返回的结果
        Integer integer = completableFuture.whenComplete((t, u) -> {
            //成功方法
            System.out.println(t); //正常的返回结果
            //出现的异常
            System.out.println(u); // 错误信息
        }).exceptionally((e) -> {
            //失败方法
            e.printStackTrace();
            e.getMessage();
            return 111;
        }).get();

    }
}

13.Volate

Volate 3大特性：

1.可见性 底层JMM机制导致

2.不原子性（配合CAS实现原子性）private volate AtomicLong ii;AtomicLong 底层方法实现是CAS的

3.禁止指令重排（我们编写的代码，会经过编译器重排，底层结构重排。所以在多线程情况下会出现并不是我们希望的执行顺序）

关于JMM的一些同步的约定

1. 线程解锁前,必须把共享变量立刻刷回主存
2. 线程加锁前,必须读取主存中的最新值到工作内存中!
3. 加锁和解锁必须是同一把锁

八种规则

不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write

不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存

不允许一个线程将没有assign的数据从工作内存同步回主内存

一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作

一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁

如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值

如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量

对一个变量进行unlock操作之前，必须把此变量同步回主内存。

14.CAS

什么是CAS

CAS就是操作预期值A尝试修改成B，如果发现A已经被修改会自旋重新尝试去修改。

底层实现使用的是UNSAFE类（可以修改地址），因为JAVA无法操作内存，c++可以操作内存。

CAS的特性：

原子性（因为是基于内存修改的，效率高）

缺点：

1.循环耗时

2.一次性只能修改一个共享变量的原子性

3.ABA问题

原子引用

因为会添加时间戳为版本号

可以解决ABA问题，使用AtomicStampedReference

public class CASDemo {
    //cas 比较并交换
//Integer
    public static void main(String[] args) {
//        AtomicInteger atomicInteger = new AtomicInteger(2020);
        AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1,1);
        //对于我们平时写的sql:乐观锁
        // public final boolean compareAndSet(int expectedValue, int newValue)
        //如果期望的值达到了就更新，否则就不更新
        new Thread(()->{
            int stamp = atomicInteger.getStamp();//获得版本号
            System.out.println("a1"+atomicInteger.getStamp());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicInteger.compareAndSet(1,2,atomicInteger.getStamp(),atomicInteger.getStamp()+1);
            System.out.println("a2"+atomicInteger.getStamp());
            atomicInteger.compareAndSet(2,1,atomicInteger.getStamp(),atomicInteger.getStamp()+1);
            System.out.println("a3"+atomicInteger.getStamp());
        },"a").start();
        new Thread(()->{
            int stamp = atomicInteger.getStamp();//获得版本号
            System.out.println("b1"+atomicInteger.getStamp());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicInteger.compareAndSet(1,6,stamp,stamp+1);
            System.out.println("b2"+atomicInteger.getStamp());
        },"a").start();
}
}

15.死锁怎么解决

1.使用jconsole和jvisualvm 监控应用

---

2.使用java\bin下的jsp命令,在使用jstack查看堆栈信息

jsp -l 
jstack 进程号

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

}
}

## 15.死锁怎么解决

1.使用jconsole和jvisualvm 监控应用



---



2.使用java\bin下的jsp命令,在使用jstack查看堆栈信息

jsp -l
jstack 进程号