java 并发库_java5线程并发库(一)

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: 等待吃饭中!

准备吃饭!

......后面还有,省略不看!