java5线程并发库部分知识点(Semaphore,CyclicBarrier,lock)
(一)CyclicBarrier类
这是一个带有计数器效果的类,可以定义一定数量的线程数,调用await()方法时,可以使给定数目的线程在该地点集合(即API中说的屏障点),当给定数目线程到达这个地点集合后,先前等待的线程才会和最后一个到来的线程往下执行任务,即相互等待的过程!每调用一次该方法,就好比设置一个地点,在该地点必须集结给定的线程数方可往下执行任务!很有规矩性!
两个构造方法,第一个用于仅仅只是指定一定数目的线程数,即在每个await()地点,必须集结给定的线程数目方可往下执行!第二个构造方法,不仅仅是指定数目,同时指定一个Runnable,即一个线程任务,在每个地点处,当最后一个线程到达时,必须要干的事情,我们就可以定义在这个Runnable中的run()方法中.就像前面的代码中,当所有人都聚集在餐桌上后,肯定有一个人最后坐上去的,那么这个最后的人(线程)宣布"开吃!",这个就是第二个构造方法比较好用的地方!
(二)Semaphore类
API管它叫信号量,但是我个人觉得还不如叫灯,一盏灯,这个Semaphore用于控制线程数,即每个线程要干某些事情,可以拿灯去干,没有灯就意味着干不了,这样也就可以用它来控制对某些东西的并发访问量!可以创建给定数目的灯数,n多个线程要做事,每个线程拿灯去干,当拿完给定数目后,后面的线程只能等着,拿着灯的线程释放灯后,先前等待的线程方可拿着灯去做事,起到了控制一定数目的访问量的效果!
下面的代码,充分展示了上面两个类比较实用的地方.
package ThreadReview1;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.ReentrantLock;
public class SemaphoreAndCyclicBarrier {
static ReentrantLock reen = new ReentrantLock();
static Semaphore s = new Semaphore(3);
static int i = 1;
static CyclicBarrier c = new CyclicBarrier(3, new Runnable() {
@Override
public void run() {
if (i == 1) {
System.out.println("准备吃饭!");
}
i = i - 1;
}
});
public static void main(String[] args) {
// ReentrantLock,CyclicBarrire,Semaphore的使用(java5线程并发库中的内容)
// 一般吃饭饭桌人到齐了才开始吃饭,这就是一个等待的过程,如此一桌吃完了下一桌也是如此
ExecutorService e = Executors.newCachedThreadPool();
for (int i = 1; i <= 30; i++) {
e.submit(new Runnable() {
@Override
public void run() {
try {
s.acquire();
waiting();
c.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
eating();
try {
Thread.sleep(3000);
c.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
finish();
try {
c.await();
if (c.getNumberWaiting() == 0) {
reset();
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
s.release();
}
});
}
}
public static void reset() {
i = 1;
}
public static void finish() {
reen.lock();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":吃完");
reen.unlock();
}
public static void eating() {
try {
Thread.sleep(2000);
} catch (InterruptedException e2) {
e2.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 在吃饭!");
}
public static void waiting() {
reen.lock();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 等待吃饭中!");
reen.unlock();
}
}
以上代码用于模拟先后吃饭的问题,结果如下:
pool-1-thread-2: 等待吃饭中!
pool-1-thread-10: 等待吃饭中!
pool-1-thread-4: 等待吃饭中!
准备吃饭!
pool-1-thread-10: 在吃饭!
pool-1-thread-2: 在吃饭!
pool-1-thread-4: 在吃饭!
pool-1-thread-10:吃完
pool-1-thread-2:吃完
pool-1-thread-4:吃完
pool-1-thread-8: 等待吃饭中!
pool-1-thread-6: 等待吃饭中!
pool-1-thread-1: 等待吃饭中!
准备吃饭!
pool-1-thread-8: 在吃饭!
pool-1-thread-6: 在吃饭!
pool-1-thread-1: 在吃饭!
pool-1-thread-1:吃完
pool-1-thread-6:吃完
pool-1-thread-8:吃完
pool-1-thread-3: 等待吃饭中!
pool-1-thread-16: 等待吃饭中!
pool-1-thread-20: 等待吃饭中!
准备吃饭!
......后面还有,省略不看!