java5线程并发库(一)-CSDN博客

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: 等待吃饭中!
准备吃饭!
......后面还有,省略不看!

转载于:https://my.oschina.net/u/3384770/blog/911305