JUC扩展（高并发）

JUC概述：

在java5.0中提供了java.util.current包（简称juc），中提供了许多在并发编程工程中常用的工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO、轻量级框架、还提供了多线程上下文的Collectiion的实现。

Volatile:异变的，不稳定的

volatile：当多个线程并发操作数据时，可以保证内存中的数据可见性，相较于synchronized是一个较为轻量级的同步策略。但是其不具备互斥性，不能保证变量的原子性。

volatile和synchronized的区别

volatile ：可是保证内存的可见性，也可以防止指令重排序，但是不能保证原子性。

synchronized：可以保证原子性，也可以保证内存的可见性，但是不能防止指令重排序。

什么是指令从排序：

简单来说：

创建一个变量分为三部1、在堆内存中开辟空间 2、调用构造方法初始化 3、在栈中给变量添加地址。

通常是正常按123的顺序进行的，然而虚拟机为了追求效率和速度，会进行优化按照132的顺序的进操作，这中行为在单线程的运行环境是一个很好的行为。但是在多线程中这样会导致空指针异常。这就是虚拟机的指令重排序。

可见性

多个线程对同一个变量（称为：共享变量）进行操作，但是这多个线程有可能被分配到多个处理器中运行，那么编译器会对代码进行优化，当线程要处理该变量时，多个处理器会将变量从主存复制一份分别存储在自己的存储器中，等到进行完操作后，再赋值回主存。

这样做的好处是提高了运行的速度，同样优化带来的问题之一是变量可见性——如果线程t1与线程t2分别被安排在了不同的处理器上面，那么t1与t2对于变量A的修改时相互不可见，如果t1给A赋值，然后t2又赋新值，那么t2的操作就将t1的操作覆盖掉了，这样会产生不可预料的结果。因此，需要保证变量的可见性（一个线程对共享变量值的修改，能够及时地被其它线程看到）。

案例演示：https://mp.csdn.net/postedit/99230015

i++的原子性问题：

(1) i++的操作实际上分为三个步骤: “读-改-写”;
i++可拆分为:
int temp1=i;
int temp2=temp+1;
i=temp2;
使用 javap -c Demo.class 可查看字节码
(2) 原子性: 就是"i++"的"读-改-写"是不可分割的三个步骤;
(3) 原子变量: JDK1.5 以后, java.util.concurrent.atomic包下,提供了常用的原子变量;
3.1 原子变量中的值,使用volatile 修饰,保证了内存可见性;
3.2 CAS(Compare-And-Swap) 算法保证数据的原子性;

CAS算法：

CAS是硬件对于并发的支持，针对多处理器操作而设计的处理器中的一个特殊指令，用于管理对并发数据的并发访问。

CAS是一种无锁非阻塞算法（乐观锁）的实现。

CAS算法的原理

取出旧预估值A

需要读写的内存值V

将写入的更新值 B

当且仅当AV时VB否则将不执行任何操作，并且这个交换过程属于原子过程。
模拟CAS算法
那么大家有没有思考一个问题：我们采用CAS算发要求前后一致，但是一个变量如果改变之后又变回原值了，我们应该怎么区分。由此引出了ABA问题。
ABA问题：
在CAS算法中，需要取出内存中某时刻的数据（由用户完成），在下一时刻比较并替换（由CPU完成，该操作是原子的）。这个时间差中，会导致数据的变化。
假设如下事件序列：
线程 1 从内存位置V中取出A。
线程 2 从位置V中取出A。
线程 2 进行了一些操作，将B写入位置V。
线程 2 将A再次写入位置V。
线程 1 进行CAS操作，发现位置V中仍然是A，操作成功。

尽管线程 1 的CAS操作成功，但不代表这个过程没有问题——对于线程 1 ，线程 2 的修改已经丢失。

Lock接口：
synchroniezd同步锁的 缺陷
1、同步锁由于种种原因不能及时释放锁，其他的线程只能一直等待。
2、使用一个锁进入同一个等待队列，需要全部唤醒。
3、不能完成读写锁的操作。

案例：使用Lock实现三个线程交替输出20遍A、B、C
public class Alternative {

private Lock lock=new ReentrantLock();
//三个对象
Condition conditionA=lock.newCondition();
Condition conditionB=lock.newCondition();
Condition conditionC=lock.newCondition();
private int num=1;// 1 a  2 b  3 c
private int count=1;

public void outputA() {
    lock.lock();//上锁
    try {
        if(num!=1) {
            try {
                conditionA.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        System.out.println("A");
        num=2;
        conditionB.signal();


    } finally {
        lock.unlock();
    }
}
public void outputB() {
    lock.lock();//上锁
    try {
        if(num!=2) {
            try {
                conditionB.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        System.out.println("B");
        num=3;
        conditionC.signal();


    } finally {
        lock.unlock();
    }
}
public void outputC() {
    lock.lock();//上锁
    try {
        if(num!=3) {
            try {
                conditionC.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        System.out.println("C");
        System.out.println("------"+count+"------");
        count++;
        num=1;
        conditionA.signal();


    } finally {
        lock.unlock();
    }
}

}

并发集合:
我们之前知道集合有
1、List（Array List LinkedList ）
2、set（hashSet TreeSet）
3、map(HashMap TreeMap)
这些集合只适合在单线程中使用，在多线程高并发的环境下用以产生安全问题。在考虑线程安全的情况下通常采用collections下的同步集合方法（以synchronized开头的方法）。或者直接用线程安全的集合，传统集合中只有Hash Table 和 Vector 两个线程安全。
juc中线程安全的集合
➣ List和Set集合：
➣ CopyOnWriteArrayList相当于线程安全的ArrayList，实现了List接口。
CopyOnWriteArrayList是支持高并发的；
➣ CopyOnWriteArraySet相当于线程安全的HashSet，它继承了AbstractSet类，
CopyOnWriteArraySet内部包含一个CopyOnWriteArrayList对象，
它是通过CopyOnWriteArrayList实现的。
➣ Map集合：
➣ ConcurrentHashMap是线程安全的哈希表（相当于线程安全的HashMap）；
它继承于AbstractMap类，并且实现ConcurrentMap接口。
ConcurrentHashMap是通过“锁分段”来实现的，它支持并发；
➣ ConcurrentSkipListMap是线程安全的有序的哈希表（相当于线程安全的TreeMap）；
它继承于AbstactMap类，并且实现ConcurrentNavigableMap接口。
ConcurrentSkipListMap是通过“跳表”来实现的，它支持并发；
➣ ConcurrentSkipListSet是线程安全的有序的集合（相当于线程安全的TreeSet）;
它继承于AbstractSet，并实现了NavigableSet接口。
ConcurrentSkipListSet是通过ConcurrentSkipListMap实现的，它也支持并发；
➣ Queue队列：
➣ ArrayBlockingQueue是数组实现的线程安全的有界的阻塞队列；
➣ LinkedBlockingQueue是单向链表实现的（指定大小）阻塞队列，该队列按FIFO（先进先出）排序元素；
➣ LinkedBlockingDeque是双向链表实现的（指定大小）双向并发阻塞队列，
该阻塞队列同时支持FIFO和FILO两种操作方式；
➣ ConcurrentLinkedQueue是单向链表实现的无界队列，该队列按FIFO（先进先出）排序元素。
➣ ConcurrentLinkedDeque是双向链表实现的无界队列，该队列同时支持FIFO和FILO两种操作方式。

同步工具类
简单说三个常用的 CountDownLatch Cyclicbarrier
CountDownLatch用法
CountDownLatch（闭锁）是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才能继续执行：
（1）确保某个计算在其需要的所有资源都被初始化后才能继续执行。
（2）确保某个服务在其依赖的所有其他服务都已经启动之后才启动。
（3）等待直到某个操作所有参与者都执行完毕其他线程才执行。
测试代码
线程代码
运行结果：
CyclicBarrier类

	CyclicBarrier和CountDownLatch类似（屏障）表面意思理解为可循环使用的屏障，作用是让一组线程在到达一个屏障时被阻塞，等到最后一个线程到达屏障点，才会运行被拦截的线程继续运行。
	（1）构造函数 CyclicBarrier(int parties) 屏障拦截的线程数量
	（2）await() 调用该方法时表示线程已经到达屏障，随即阻塞

案例一：简单使用，实现多个线程同时执行
线程代码
测试代码
运行结果

CountDownLatch 和cyclicbarrier的区别
CountDownLatch只能使用一次，而后者可以使用reset（），后者适合更复杂的事务关系。
CyclicBarrier还有getNumberWaiting 获取当前阻塞的线程数量，isBroken()判断阻塞线程是否被中断。

semaphore:
　Semaphore 是 synchronized 的加强版，作用是控制线程的并发数量。就这一点而言，单纯的synchronized 关键字是实现不了的。
　用来控制同时访问特定资源的线程数量，通过协调保证合理的使用公共资源。
　比作控制车流的红绿灯，如马路要控制流量，只限制100辆车通行，其他必须在路口处等待，不能行驶在马路上，当其中有5辆离开马路，那么允许后面5辆进入马路。

线程代码
测试代码
执行结果