关于高并发的几个基本锁的学习ReentrantLock，CountDownLatch ，CyclicBarrier，Semaphore，reentrantReadWriteLock

import org.junit.Test;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/*
* 学习常用的几个锁的类
* 1.ReentrantLock  可重用锁
*
* 2.CountDownLatch  场景：任务需要在几个线程后才能执行，类似于一个计数器
*
* 3.CyclicBarrier  循环屏障   任务会在几个线程都到达时，才会一起执行，还有一个高级构造方法actionBarrier来进行优先处理
*
* 4.Semaphore  信号量     用于限制并发线程的数量
*
* 5.reentrantReadWriteLock  实现一个缓存器
* */
public class LockStudy {
@Test
public void ReentrantLockTest() {
final ReentrantLock rl = new ReentrantLock();
new Thread(new Runnable() {
public void run() {
try {
rl.lock();
Thread.sleep(3000);
System.out.println("子线程" + rl.getHoldCount());
} catch (Exception e) {
System.out.println("线程上锁异常");
} finally {
rl.unlock();
}

}
}).start();

try {
Thread.sleep(1000);
rl.lock();
System.out.println("主线程的阻塞长度" + rl.getQueueLength());
} catch (Exception e) {
System.out.println("主线程上锁失败");
} finally {
rl.unlock();
}
}

@Test
public void CountDownLatch() {
final CountDownLatch cdl = new CountDownLatch(4);

//3个线程后，才会执行下面的业务
for (int i = 0; i < 3; i++) {
new Thread(new Runnable() {
public void run() {
System.out.println("子线程");
cdl.countDown();
}
}).start();
}
try {
cdl.await(3, TimeUnit.SECONDS);
} catch (Exception e) {
System.out.println("超时自动中断");
} finally {
System.out.println("执行业务代码");
}

}

public volatile int i = 0;

@Test
public void CyclicBarrierTest() {
final CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

new Thread(new Runnable() {
public void run() {
try {
System.out.println("第一个子线程准备好了");
cyclicBarrier.await();
} catch (Exception e) {
System.out.println("第一个++++子线程+++阻塞失败");
} finally {
System.out.println("子线程执行了");
i++;
System.out.println("子线程的运行结果" + i);
}

}
}).start();
new Thread(new Runnable() {
public void run() {
try {
System.out.println("第二个子线程准备好了");

cyclicBarrier.await();
} catch (Exception e) {
System.out.println("子线程的子线程++++阻塞失败");
} finally {
System.out.println("第二个子线程执行了");
i++;
System.out.println("子线程的运行结果" + i);
}
}
}).start();
try {
try {
System.out.println("主线程线程准备好了");
Thread.sleep(3000);

} catch (Exception e) {
System.out.println("线程睡眠失败");
}
cyclicBarrier.await();
} catch (Exception e) {
System.out.println("第二个+++主线程++++阻塞失败");
} finally {
System.out.println("主线程执行了");
i++;
System.out.println("主线程结果" + i);
}

}

@Test
public void resTest() {
try {
CyclicBarrierTest();
Thread.sleep(3000);
} catch (Exception e) {

} finally {
System.out.println("最终结果" + i);
}

}

@Test
public void semaphoreTest() {
final Semaphore semaphore = new Semaphore(2);

for (int i = 0; i < 8; i++) {
new Thread(new Runnable() {
public void run() {
try {
System.out.println("获取资源");
semaphore.acquire();

Thread.sleep(2000);
System.out.println("使用资源");
//semaphore.release();

System.out.println("释放资源");
} catch (Exception e) {
System.out.println("异常");
}

}
}).start();
}
}

@Test
public void driverCarTest() {
for (int i = 0; i < 3; i++) {
Driver driver = new Driver();
new car(driver).start();
}
}

@Test
public void ReentrantReadWriteLockTest() {
for (int i=0;i<6;i++){
new Thread(new Runnable() {
public void run() {
ReentrantReadWriteLockDome demo=new ReentrantReadWriteLockDome();
demo.get("1");
System.out.println(demo.get("1")+"读数据");
}
}).start();

}
for (int i=0;i<4;i++){
new Thread(new Runnable() {
public void run() {
ReentrantReadWriteLockDome demo=new ReentrantReadWriteLockDome();
demo.put("1","hehe");
}
}).start();
}
}

//实例使用semaphore
class Driver {
final Semaphore semaphore = new Semaphore(1);

public void driverCar() {
try {
semaphore.acquire();
System.out.println("司机开始开车" + Thread.currentThread().getName() + "时间" + System.currentTimeMillis());

semaphore.release();
System.out.println("司机下车" + Thread.currentThread().getName() + "时间" + System.currentTimeMillis());

} catch (Exception e) {
System.out.println("线程异常");
}
}
}

class car extends Thread {
private Driver driver;

car(Driver driver) {
super();
this.driver = driver;
}

@Override
public void run() {
driver.driverCar();
}
}

//读写锁的使用
class ReentrantReadWriteLockDome{

private Map<String, Object> map = new HashMap<String, Object>();
private final ReentrantReadWriteLock rrwl = new ReentrantReadWriteLock();
public Object get(String id) {
Object data=map.get(id);
try {
rrwl.readLock().lock();
if (map.get(id) != null) {
System.out.println("map有数据" + Thread.currentThread().getName() + "数据：" + data);

} else {
System.out.println("没有数据"+Thread.currentThread().getName());
data=null;
}
} catch (Exception e){
System.out.println("中断异常");
}finally {
rrwl.readLock().unlock();
}
return data;
}

public void put(String id,String data){
rrwl.writeLock().lock();
map.put(id,data);
System.out.println(Thread.currentThread().getName()+"写数据"+data);
rrwl.writeLock().unlock();
}
}
}