下面介绍的是JUC包下一些线程安全类的一些简单使用和一些小demo。

Semaphore

信号量，即可以同时使用的线程数，tryrequire就是将信号量减一，release就是信号量+1，当等于0就会阻塞，大于零才会唤醒。

当需要控制线程访问数量，可以使用信号量来做控制，比较简单。

下面是使用信号量改进的数据库连接池

@Slf4j
public class SemaphoreConnection {

// 连接池对象数组
private Connection[] connections;
// 使用标记
private AtomicIntegerArray flagArrays;
// 线程池大小
private Integer poolSize;
/**
* 信号量
*/
Semaphore semaphore;

public SemaphoreConnection(){
this.poolSize = 5;
connections = new MarkConnection[5];
flagArrays = new AtomicIntegerArray(5);
for (int i = 0; i < connections.length; i++) {
connections[i] = new MarkConnection("连接" + i+1);
}
semaphore = new Semaphore(5);
}

// 连接池的初始化
public SemaphoreConnection(int poolSize) {
this.poolSize = poolSize;
connections = new MarkConnection[poolSize];
flagArrays = new AtomicIntegerArray(poolSize);
for (int i = 0; i < connections.length; i++) {
connections[i] = new MarkConnection("连接" + i);
}
semaphore = new Semaphore(poolSize);
}

// 向连接池中请求连接
public Connection getConnection(){
try {
semaphore.acquire();
} catch (InterruptedException e) {
e.printStackTrace();
}
while (true){
for (int i = 0; i < poolSize; i++) {
// 进行cas请求，如果请求失败就失败
if (flagArrays.compareAndSet(i,0,1)){
return connections[i];
}
}
}
}

/**
* 释放连接
* @param con
*/
public void releaseConnection(Connection con){
for (int i = 0; i < poolSize; i++) {
if (con == connections[i]){
// 将连接标识置为0即空间连接
flagArrays.set(i,0);
semaphore.release();
}
}
}

public static void main(String[] args) {
SemaphoreConnection myConnectionPoll = new SemaphoreConnection(3);
for (int i = 0; i < 10; i++) {
new Thread(() ->{
MarkConnection connection =(MarkConnection) myConnectionPoll.getConnection();
log.debug("获得锁{}",connection.getConName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
myConnectionPoll.releaseConnection(connection);
log.debug("释放锁{}",connection.getConName());
}).start();
}
}
}

CountDownLatch

就是一个用来计数的，来解决线程之间通信的问题。

比如我需要两个线程执行完毕后再去执行主线程，我们可以用join方法，但是我们同样可以使用这个类来控制。

通过一个count，当其被减为0时，调用await阻塞的线程就会唤醒。

// 一个简单的demo
@Slf4j
public class Test2 {

public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(2);
//        for(int i = 0;i < 3;i++){
new Thread(()->{
log.debug("来啦");
try {
Thread.sleep(1000);
countDownLatch.countDown();

} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("干啦兄弟们");
}).start();
new Thread(()->{
log.debug("来啦");
try {
Thread.sleep(2000);
countDownLatch.countDown();

} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("干啦兄弟们");
}).start();
//        }
countDownLatch.await();
log.debug("开吃了兄弟们");
}

}

同时可以作为微服务下的多线程调用，当我们需要多个微服务的结果时，我们可以使用多线程，调用多线程池使用多线程的方法远程调用，可以使用该类控制主线程等待线程池中的线程执行完后执行主线程。但是使用Future可以解决问题，所以还是建议使用future，使用callable方法。

CyclicBarrier

作为一个和CountDownLatch功能相似，但是它却是可以循环使用的，当其置为0时，唤醒线程后，就会恢复到初始值。可以继续使用，而CountDownLatch却是一次性的，需要重复创建线程。

CyclicBarrier主要是调用一个await方法，等待其他线程，当到达数量的线程完成后，就会唤醒被await方法阻塞的线程。

// demo
@Slf4j
public class Test3 {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

new Thread(()->{
log.debug("来啦");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("干啦兄弟们");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
log.debug("来啦");
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("干啦兄弟们");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
log.debug("来了啊");
}
}

ConcurrentHashMap

保证了多线程下hashmap的安全。

jdk1.7时会产生死链，因为jdk1.7时多线程下是在链表头往里面加，而 不是1.8在链表尾加，所以会出现多线程下链表出现环，无法结束程序。

Concurrent类在多线程下的表现为

• 内部使用cas进行优化，可以支持较大的吞吐量
• 弱一致性 迭代时的弱一致性，当在迭代是被更新，迭代不会报错但是会表现出旧值
• size的弱一致性，会读到旧值
• 读取一致性