## 1、ReadWriteLock讀寫鎖
概念很好理解，下面是代碼：
package com.test.thread3;
import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteReentrantLockTest {
private static Lock lock = new ReentrantLock();
private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private static Lock readLock = readWriteLock.readLock();
private static Lock WriteLock = readWriteLock.writeLock();
private int value;
public Object handleRead(Lock lock) throws InterruptedException {
try {
lock.lock();
Thread.sleep(1000);
return value;
} finally {
lock.unlock();
}
}
public void handleWrite(Lock lock, int index) throws InterruptedException {
try {
lock.lock();
Thread.sleep(1000);
value = index;
} finally {
lock.unlock();
}
}
public static void main(String args[]) {
final ReadWriteReentrantLockTest demo = new ReadWriteReentrantLockTest();
Runnable read = new Runnable() {
public void run() {
try {
//demo.handleRead(lock);
int i= (Integer) demo.handleRead(readLock);
System.out.println("read:"+i);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
Runnable write = new Runnable() {
public void run() {
try {
int i = new Random().nextInt();
System.out.println(Thread.currentThread().getId()+" i "+i);
demo.handleWrite(WriteLock, i);
// demo.handleWrite(lock, new Random().nextInt());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
for(int i=0;i<18;i++){
new Thread(read).start();
}
for(int i=18;i<20;i++){
new Thread(write).start();
}
try {
Thread.sleep(3000);
System.out.println(demo.value);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
可以觀察到使用普通的ReetrantLock 和 ReentrantReadWriteLock執行時間的區別。
##2、倒計時器 CountDownLatch
CountDownLatch 是一個非常使用的多線程控制工具類。CountDown 在英文中意爲倒計數，Latch是門閂的意思。 門閂的含義是：把門鎖起來，不讓裏面的線跑出來。因此這個歌工具通常用來控制線程等待，它可以讓某一個線程等待直到倒計時結束，再開始執行。
public class CountDownLatchDemo implements Runnable {
static final CountDownLatch end = new CountDownLatch(10);
static final CountDownLatchDemo demo = new CountDownLatchDemo();
public void run() {
try {
Thread.sleep(new Random().nextInt(10) * 1000);
System.out.println("check complete");
end.countDown();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String args[]) throws InterruptedException {
ExecutorService exec = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
exec.submit(demo);
}
end.await();
System.out.println("Fire");
exec.shutdown();
}
}##3、循環柵欄 CyclicBarrier
CyclicBarrier是另外一種多線程併發控制的實用工具。和CountDownLatch非常類似，它可以實現線程間的計數等待，但它的功能比CountDownLatch更加複雜強大。它有循環的功能，也就是這個計數器可以反覆使用。
public class Soldier implements Runnable {
private String soldier;
private final CyclicBarrier cyclic;
Soldier(CyclicBarrier cyclic, String soldierName) {
this.cyclic = cyclic;
this.soldier = soldierName;
}
public void run() {
try {
cyclic.await(); // 等待前面的任務執行完成。 再一起執行後面的任務。
doWork();
cyclic.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
}
}
void doWork(){
try{
Thread.sleep(Math.abs(new Random().nextInt()%10000));
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(soldier+": 任務完成。");
}
}
public class BarrierRun implements Runnable {
boolean flag;
int N;
public BarrierRun(boolean flag, int N){
this.flag = flag;
this.N=N;
}
public void run() {
if(flag){
System.out.println("司令：[士兵 "+N+"個， 任務完成！");
}else{
System.out.println("司令：[士兵 "+N+"個， 集合完畢！");
flag = true;
}
}
}
public class CyclicBarrierDemo {
public static void main(String args[]){
final int N=10;
Thread[] allSoldier = new Thread[N];
boolean flag = false;
CyclicBarrier cyclic = new CyclicBarrier(N,new BarrierRun(flag,N));
System.out.println("集合隊伍");
for(int i=0;i<11;++i){
System.out.println("士兵 "+i+"報道！");
allSoldier[i] = new Thread(new Soldier(cyclic,"士兵"+i));
allSoldier[i].start();
}
}
}
##4、線程阻塞工具欄 LockSupport
LockSupport 是一個非常方便使用的線程阻塞工具，它可以在線程內任意位置讓線程阻塞。和Thead。suspend 相比，他彌補了由於resume在前發生，導致線程無法繼續執行的情況。和Object.wait 相比，他不需要先獲得某個對象的鎖，也不會拋出InterruptedException異常。
LockSupport使用類似信號量的機制。它爲每個線程準備了一個許可，如果許可可用，那麼park函數立即返回，並且消費這個許可，如果許可不可用，就會阻塞，而unpark 則使得一個許可變爲可用（但是和信號量不同的是，許可不能累加，你不可能擁有超過一個許可，它永遠只有一個。）
public class ChangeObjectThread extends Thread {
public static Object u = new Object();
public ChangeObjectThread(String name) {
super.setName(name);
}
public void run() {
synchronized (u) {
System.out.println("in " + getName());
LockSupport.park();
LockSupport.park();
}
}
}
public class LockSupportDemo {
static ChangeObjectThread t1 = new ChangeObjectThread("t1");
static ChangeObjectThread t2 = new ChangeObjectThread("t2");
public static void main(String[] args) throws InterruptedException {
t1.start();
LockSupport.unpark(t1);
Thread.sleep(1000);
LockSupport.unpark(t1);// 這兩個許可如果放在一塊，只會產生一個許可，因爲線程中有兩個park，所以會一直阻塞，因此需要使用sleep分開。
t2.start();
//LockSupport.park(t1);
LockSupport.unpark(t2);
Thread.sleep(1000);
LockSupport.unpark(t2);
t1.join();
t2.join();
}
}