java.util.concurrent 包下的常见类（JUC）

1、ReentrantLock

可重入互斥锁
注意事项：
a) lock（） 写在try之前。防止没有枷锁成功，影响正常逻辑调试。
b)一定要记得在finally里面进行unLock（）。

2、信号量

一个计数信号量，主要用于控制多线程对共同资源库访问的限制。
着重说两个方法：
acquire（）void：尝试获取锁，如果可以正常获取到，则执行后面的业务逻辑，如果获取失败，则阻塞等待。
release（） void：释放锁
这里用停车场的思想来演示一下：

import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 信号量演示
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        //创建信号量
        Semaphore semaphore = new Semaphore(2);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,10,0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(100));
        for (int i = 0; i < 4; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"到达停车场");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //试图进入停车场
                    try {
                        //尝试获取锁
                        semaphore.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //当代码执行到此处，说明已经获取到锁了
                    System.out.println(Thread.currentThread().getName()+"进入停车场---------------");
                    //车辆停留的时间构建
                    int num = 1+new Random().nextInt(5);
                    try {
                        Thread.sleep(num*1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //车辆离开停车场
                    System.out.println(Thread.currentThread().getName()+"离开停车场。。。。。。。。。");
                    //释放锁
                    semaphore.release();
                }
            });
        }
        //创建任务1

    }
}

可以看到，最多有两辆车进入停车场，其他车辆只能停车等待，当停车场有空位的时候才能进去。也就是说信号量规定了多少线程能够访问资源的数量。

3、计数器 CountDownLauth

计数器是用来保障一组线程同时完成某个操作之后，在执行后面的代码。
着重强调两个方法：
await(): 当线程数量不满足CountDownLatch的数量的时候，执行此代码会阻塞等待，直到数量满足之后，在执行await（）之后的代码。
CountDown():计数器数量减一。

这里用跑步比赛演示：当所有运动员都到达终点之后才会公布比赛结果。

import java.util.concurrent.CountDownLatch;

/**
 * 计数器演示
 */
public class ThreadDemo2 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);

        for (int i = 1; i < 6; i++) {
            int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"开始起跑");
                    try {
                        Thread.sleep(finalI*1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"到达终点");
                    //计数器减一
                    countDownLatch.countDown();
                }
            }).start();
        }
        //阻塞等待
        countDownLatch.await();
        System.out.println("所有人都到达终点了，公布排名");

    }
}

CountDownLatch如何实现？
答：在CountDownLatch里面有一个计数器，每次调用CountDown方法的时候，计数器数量减一，直到减到零之后，就可以执行await之后的代码了。
CountDownLatch的缺点：
CountDownLatch的计数器的使用是一次性的，当用完一次，就不在使用了。
于是就有了下面的类

4、循环屏障（CyclicBarrier）

着重讲一个方法：
await：执行有两个作用，计数器–，如果不为零，阻塞等待，如果为零，执行后面的代码
ps：当计数器为零时，会执行await之后的代码，将计数器重置为创建时的值。

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

/**
 * 循环屏障演示
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("执行了Runnable任务");
            }
        });

        for (int i = 1; i < 11; i++) {
            int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"开始起跑");
                    try {
                        Thread.sleep(200*finalI);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //等待
                    try {
                        System.out.println(Thread.currentThread().getName()+"等待其他人----------");
                        //计数器减一，判断计数器是否为零
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    //代码执行到这里，说明已经有一组线程已经满足条件了
                    System.out.println();
                    System.out.println(Thread.currentThread().getName()+"执行结束。。。。。。。。");
                }
            }).start();
        }
    }
}

就像是一组一组执行的，每组执行玩一次，宣布一次结果。

CyclicBarrier和CountDownLatch的区别：
答：CountDownLatch的计数器只能使用一次，而CyclicBarrier可以重复使用。

ConcurrentHashMap

HashMap是非线程安全容器：HashMap->数组+链表/红黑树
不安全的原因：
-JDK1.7死循环
-JDK1.8数据覆盖

HashMap负载因子（加载因子）默认值：0.75 扩容的时候用：size*0.75大于这个值进行扩容
0.75：尽量避免哈希冲突所带来的性能开销问题，用空间换时间方案。
HashMap在1.7采用头插

HashMap的线程安全方案：使用ConcurrentHashMap
JDK1.7：是将ConcurrentHashMap分成几个segment进行加锁的。（悲观锁）
lock unLock
JDK1.8优化：锁优化，读的时候不加锁，写的时候加锁，使用了大量的CAS，Voiltail。

HashTable 线程安全的容器
给put方法整体加锁，因此一般情况下不会时候HashTable.

HashMap、HashTable、ConcurrentHashMap区别：
答：
1、HashMap非线程安全的容器，它在1.7造成死循环，在1.8会造成数据覆盖。
HashTable和ConcurrentHashMap都是线程安全的
2、HashTable实现线程安全的手段比较简单，它在put方法整体加了一把锁，使用synchronized修饰，因此性能不高，所以使用频率不高。而ConcurrentHashMap是HashMap在多线程下的替代方案，它在1.7的时候使用Lock加分段的方案来实现线程安全的。
在1.8的时候使用了大量的CAS，volatile来实现线程的，并且在JDK1.8的时候读取的时候不加锁（有可能读到的数据不是最新，因为读取和写入可以同时写入），只有在写的时候加速。