一、ThreadLocal
ThreadLocal类用于隔离多线程中使用的对象，为ThreadLocal类中传递的泛型就是要隔离的对象，简单的来说：如果我们在主线程创建了一个对象，并且需要给下面的多线程任务都传递这个对象，那么如果这个对象传递到ThreadLocal，那么每个线程获取的对象都是独立的，不会受其他线程的改变而改变。
ThreadLocal中一共有三个常用方法：
get()方法：获取与当前线程关联的ThreadLocal值。
set(T value)方法：设置与当前线程关联的ThreadLocal值。
initialValue()方法：设置与当前线程关联的ThreadLocal初始值。
我们来看一个列子，创建两个线程，两个线程共同使用一个对象，我们来观察这个对象的值以及ThreadLocal中这个对象的值：
对象User类：
public class User {
int num;
public User(int num) {
this.num = num;
}
/**
* 我们只使用get方法，并且每次获取num都为其加1
*
* 使用synchronized保证getNum获取的num是线程安全的
* @return
*/
synchronized public int getNum() {
return num++;
}
}
线程任务类：
public class ThreadlocaDemo extends Thread{
User user;
ThreadlocaDemo(User user){
this.user=user;
}
/**
* 创建一个ThreadLocal对象，为它的泛型传入User
*/
ThreadLocal<User> userLoacl = new ThreadLocal<User>(){
/**
* 初始化方法，将设置user中的初始值
*/
@Override
protected User initialValue() {
User user=new User(10);
return user;
}
};
@Override
public void run() {
for (int i = 1; i <3 ; i++) {
//休息一会儿
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//打印user中获取的值
System.out.println(getName()+"user对象的值"+user.getNum());
//打印ThreadLocal中的user对象的值
System.out.println(getName()+"ThreadLocal中的user对象的值"+userLoacl.get().getNum());
}
}
}
测试类：
public class Main {
public static void main(String[] args) {
//创建一个共用的对象
User user=new User(10);
//创建两个线程任务
ThreadlocaDemo threadlocaDemo1=new ThreadlocaDemo(user);
ThreadlocaDemo threadlocaDemo2=new ThreadlocaDemo(user);
threadlocaDemo1.setName("这是1号线程：");
threadlocaDemo2.setName("这是2号线程：");
threadlocaDemo1.start();
threadlocaDemo2.start();
}
}
运行的结果：
根据运行结果我们可以清楚的看到，在ThreadLocal中的user对象是隔离的，外面的user对象没有被隔离，被两个线程都进行修改过。
二、Exchanger
Exchanger可以交换两个线程的数据，它的实现思想是当线程进行到Exchanger类调用的exchange方法时，会阻塞当前线程，直到有其他线程也进入了exchange方法中就开始交换两个线程的数据。
需要注意的是，exchange只能作为两个线程进行交换数据，如果有多个线程，那么获取的数据是随机的。
我们来看一个列子：
线程任务类，交换一个字符串数据
public class ExchangerThread extends Thread{
//Exchanger对象
Exchanger<String> change;
//当前线程中的数据,需要交换的数据
String thisStr;
public ExchangerThread(Exchanger<String> change, String thisStr) {
this.change = change;
this.thisStr = thisStr;
}
@Override
public void run() {
try {
//exchange方法，将要交换的数据传递到exchange方法中
//获取的值就是交换后的数据
String getStr=change.exchange(thisStr);
System.out.println(getName()+getStr);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
测试类：
public class ExchangerDemo {
public static void main(String[] args) {
//创建Exchanger对象
Exchanger<String> exchanger=new Exchanger<>();
//创建两个线程交换数据
ExchangerThread exchangerThread1=new ExchangerThread(exchanger,"这是1号线程的数据");
ExchangerThread exchangerThread2=new ExchangerThread(exchanger,"这是2号线程的数据");
exchangerThread1.setName("我是1号线程，交互获取的数据是：");
exchangerThread2.setName("我是2号线程，交互获取的数据是：");
exchangerThread1.start();
exchangerThread2.start();
}
}
运行的结果：
可以看到如果只有两个线程，交换的数据是确定的，如果有多个线程呢，我们在测试类中多添加几个线程：
public class ExchangerDemo {
public static void main(String[] args) {
//创建Exchanger对象
Exchanger<String> exchanger=new Exchanger<>();
//创建两个线程交换数据
ExchangerThread exchangerThread1=new ExchangerThread(exchanger,"这是1号线程的数据");
ExchangerThread exchangerThread2=new ExchangerThread(exchanger,"这是2号线程的数据");
ExchangerThread exchangerThread3=new ExchangerThread(exchanger,"这是3号线程的数据");
ExchangerThread exchangerThread4=new ExchangerThread(exchanger,"这是4号线程的数据");
exchangerThread1.setName("我是1号线程，交互获取的数据是：");
exchangerThread2.setName("我是2号线程，交互获取的数据是：");
exchangerThread3.setName("我是3号线程，交互获取的数据是：");
exchangerThread4.setName("我是4号线程，交互获取的数据是：");
exchangerThread1.start();
exchangerThread2.start();
exchangerThread3.start();
exchangerThread4.start();
}
}
运行的结果：
可以看到，多个线程进行交换数据，数据的交换是随机的。
三、CountDownLatch
CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作前，它允许一个或多个线程一直等待。简单的说就是一个线程组正在工作，但是他们执行的任务都有一道门，这道门是关着的，会导致每个线程接下来的任务都暂停进行，简单的说就是线程被阻塞了，只有当所有线程都在这个门前，即所有线程都被阻塞了，才会继续执行。
当然了，上面的例子不太准确，CountDownLatch中实现所有线程都完成任务才能继续进行的方式不是这样，它是有一个计算器，当这个计算器的值等于0时，才会释放当前阻塞的所有线程。
CountDownLatch中常用的方法：
getCount()：获取当前计数器剩余计数
countDown()：计算器的值减1
await()：阻塞当前线程，只有当计算器的值等于0时，才会释放当前线程
例子：
创建一个CountDownLatch对象，它的计数器的值为3，我们创建3个线程，每个线程执行完任务后先countDown()，再调用await()方法等待：
线程任务类：
public class CountDownLatchDemo extends Thread {
// 创建CountDownLatch对象
CountDownLatch latch;
// 休眠时间
int num;
// 构造器传参
public CountDownLatchDemo(CountDownLatch latch, int num) {
super();
this.latch = latch;
this.num = num;
}
@Override
public void run() {
try {
System.out.println("当前执行的是：" + getName());
// 让线程执行任务
Thread.sleep(num);
// 线程执行完成任务后，对CountDownLatch的值减1
latch.countDown();
System.out.println(getName() + "完成任务,等待其他线程执行任务");
// 这里让线程阻塞，只有当CountDownLatch等于0时才继续执行线程
// 即当所有的线程都完成了任务，才开始一起继续执行下面的任务
latch.await();
System.out.println("所有线程都完成后才执行的代码：" + getName());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
测试类：
public class Main {
public static void main(String[] args) {
//创建一个CountDownLatch对象，设置值为3，表示当有3个线程都完成任务后，才开始执行阻塞后的代码
CountDownLatch latch=new CountDownLatch(3) ;
//创建3个线程，每个线程的CountDownLatch对象是同一个
CountDownLatchDemo countDownLatchDemo1=new CountDownLatchDemo(latch,100);
CountDownLatchDemo countDownLatchDemo2=new CountDownLatchDemo(latch,1000);
CountDownLatchDemo countDownLatchDemo3=new CountDownLatchDemo(latch,2000);
countDownLatchDemo1.setName("1号线程");
countDownLatchDemo2.setName("2号线程");
countDownLatchDemo3.setName("3号线程");
countDownLatchDemo1.start();
countDownLatchDemo2.start();
countDownLatchDemo3.start();
}
}
运行的结果：
根据运行的结果我们可以看到，1、2、3号线程在执行完成任务后都等待，等待3号执行完成任务，使得计算器的值为0时，开始释放所有线程。
四、CyclicBarrier、
CyclicBarrier与countDownLatch相识，都有一个计算器，但是两个类不同的是：countDownLatch都是当计算器的值为0时才释放所有线程，而CyclicBarrier是当阻塞的线程数等于计算器的值时，才开始释放线程。这两个类最大的区别就是一个是线程开始时的阻塞，一个是线程结束前的阻塞。
CyclicBarrier可以使一定数量的线程反复地在栅栏位置处汇集。当线程到达栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。如果所有线程都到达栅栏位置，那么栅栏将打开，此时所有的线程都将被释放，而栅栏将被重置以便下次使用。
我们来看一个例子：阻塞了三个线程后，开始执行：
线程任务类：
public class CyclicBarrierDemo extends Thread{
//创建CyclicBarrier对象
CyclicBarrier cyclicBarrier;
//休眠时间
int num;
public CyclicBarrierDemo(CyclicBarrier cyclicBarrier, int num) {
super();
this.cyclicBarrier = cyclicBarrier;
this.num = num;
}
@Override
public void run() {
try {
System.out.println("任务开始，当前执行的是："+getName());
//让线程执行任务
Thread.sleep(num);
System.out.println(getName()+"准备工作完成,等待其他线程执行任务");
//执行完成后，等待其他线程完成任务
cyclicBarrier.await();
Thread.sleep(num);
System.out.println("所有线程都准备好后才执行的代码：我是"+getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}
测试类：
public static void main(String[] args) {
//阻塞的线程数量
int waitNum=3;
//创建cyclicBarrier对象
CyclicBarrier cyclicBarrier=new CyclicBarrier(waitNum);
CyclicBarrierDemo cyclicBarrierDemo1=new CyclicBarrierDemo(cyclicBarrier,100);
CyclicBarrierDemo cyclicBarrierDemo2=new CyclicBarrierDemo(cyclicBarrier,1000);
CyclicBarrierDemo cyclicBarrierDemo3=new CyclicBarrierDemo(cyclicBarrier,2000);
cyclicBarrierDemo1.setName("1号线程：");
cyclicBarrierDemo2.setName("2号线程：");
cyclicBarrierDemo3.setName("3号线程：");
cyclicBarrierDemo1.start();
cyclicBarrierDemo2.start();
cyclicBarrierDemo3.start();
}
}
运行的结果：
五、Semaphore
semaphore的作用是控制资源的访问，他能够限制当前资源能够被多少个线程所访问。它和线程池有些类似，但是与线程池不同的是，线程池是提前生成好了多个线程放进线程池里，如果超出线程池设置的数量，那么线程是不会被创建，但是semaphore超出了设置的线程数，还会继续创建线程。
semaphore中的方法：
acquire(): 获取许可
release(): 释放资源
availablePermits(): 获取当前可用的资源数量
semaphore的构造方法
public Semaphore(int permits,boolean fair)
permits:初始化设置线程的数据
fair:表示是否以线程获取锁的顺序来执行线程，就是是否用公平锁，false表示不使用，默认是false
我们来看一个例子，创建1个线程数组和一个semaphore任务类，线程数组的长度为10，semaphore任务类的值为5，我们观察它们的执行方式：
semaphore任务类：
public class SemaphoreDemo extends Thread {
Semaphore semaphore;
public SemaphoreDemo(Semaphore semaphore) {
super();
this.semaphore = semaphore;
}
@Override
public void run() {
try {
// 获取许可
semaphore.acquire();
System.out.println("任务开始，当前执行的是：" + getName());
// 让线程执行任务
Thread.sleep(2000);
// 执行完成后，释放资源
semaphore.release();
} catch (Exception e) {
e.printStackTrace();
}
}
}
测试类：
public class Main {
public static void main(String[] args) {
// 创建Semaphore对象
Semaphore semaphore = new Semaphore(5);
// 创建一个长度为10的线程数组
Thread[] threadAry = new Thread[10];
for (int i = 0; i < threadAry.length; i++) {
// 线程数组的值都添加线程任务
SemaphoreDemo semaphoreDemo = new SemaphoreDemo(semaphore);
semaphoreDemo.setName(i + "号线程");
threadAry[i] = semaphoreDemo;
}
// 执行线程任务
for (int i = 0; i < threadAry.length; i++) {
threadAry[i].start();
}
}
}