Semaphore使用

Semaphore（信号量），通常用来限制可以访问资源的线程数量，使他们能够正确、合理地使用公共资源。比如1个餐厅最多可容纳10人就餐，多余的人就需要等位。

Semaphore的acquire方法用来获取一个资源的许可，release方法用来释放一个资源的许可。

/**
 * Semaphore demo：一个餐厅同时可容纳10人吃饭，多余的人将会排队等候
 * 
 * @author usr1999 2015-1-18
 */
public class SemaphoreDemo {

	public static void main(String[] args) {
		for (int i = 0; i < 30; i++) {
			Guest guest = new Guest();
			Thread run = new Thread(guest);
			run.start();
		}
	}
}

/**
 * 餐厅
 */
class Restaurant {
	// 信号量为共享资源的属性
	private static Semaphore semp = new Semaphore(10); // 只容纳10个人就餐

	public static void eat() {
		try {
			semp.acquire();
			System.out.println(Thread.currentThread().getName()
					+ " is eating in restaurant");
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			System.out.println("1 thread release");
			semp.release(); // 释放一个许可
		}
	}
}

/**
 * 客人
 */
class Guest implements Runnable {

	@Override
	public void run() {
		Restaurant.eat();
	}
}

 

 demo program 2:

import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Java 5.0里新加了4个协调线程间进程的同步装置，它们分别是：
 * Semaphore, CountDownLatch, CyclicBarrier和Exchanger.
 * 本例主要介绍Semaphore。
 * Semaphore是用来管理一个资源池的工具，可以看成是个通行证，
 * 线程要想从资源池拿到资源必须先拿到通行证，
 * 如果线程暂时拿不到通行证，线程就会被阻断进入等待状态。
 */
public class SemaphoreTest {
	/**
	 * 模拟资源池的类
	 * 只为池发放2个通行证，即同时只允许2个线程获得池中的资源。
	 */
	public static class Pool {
		// 保存资源池中的资源
		ArrayList<String> pool = null;
		// 通行证
		Semaphore pass = null;
		Lock lock = new ReentrantLock();
		public Pool(int size) {
			// 初始化资源池
			pool = new ArrayList<String>();
			for (int i = 0; i < size; i++) {
				pool.add("Resource " + i);
			}
			// 发放2个通行证
			pass = new Semaphore(2);
		}

		public String get() throws InterruptedException {
			// 获取通行证,只有得到通行证后才能得到资源
			System.out.println("Try to get a pass...");
			pass.acquire();
			System.out.println("Got a pass");
			return getResource();
		}

		public void put(String resource) {
			// 归还通行证，并归还资源
			System.out.println("Released a pass");
			pass.release();
			releaseResource(resource);
		}

		private String getResource() {
			lock.lock();
			String result = pool.remove(0);
			System.out.println("资源 " + result + " 被取走");
			lock.unlock();
			return result;
		}

		private void releaseResource(String resource) {
			lock.lock();
			System.out.println("资源 " + resource + " 被归还");
			pool.add(resource);
			lock.unlock();
		} 
	}
	
	public static void testPool() {
		// 准备10个资源的资源池
		final Pool aPool = new Pool(10);
		Runnable worker = new Runnable() {
			public void run() {
				String resource = null;
				try {
					//取得resource
					resource = aPool.get();
					//用resource做工作
					System.out.println("I am working on " + resource);
					Thread.sleep(500);
					System.out.println("I finished on " + resource);
				} catch (InterruptedException ex) {
				}
				//归还resource
				aPool.put(resource);
			}
		};
		// 启动5个任务
		ExecutorService service = Executors.newCachedThreadPool();
		for (int i = 0; i < 5; i++) {
			service.submit(worker);
		}
		service.shutdown();
	} 
	
	public static void main(String[] args) {
		SemaphoreTest.testPool();
	}
}