什么是信号量机制

信号量机制是一种通过使用计数器来控制共享资源访问的机制，计数器计数的是共享资源的访问许可，如果计数器大于0则允许访问，如果为0，则拒绝访问。Java在java.util.concurrent包中提供了Semaphore类实现该机制。

Semaphore工作流程

通常，在线程想要访问共享资源时，会用到Semaphore获取许可。

• 如果Semaphore计数大于0，则获得许可，Semaphore计数器减1
• 否则，线程将被阻塞，直到获得许可。
• 当线程不再需要访问共享资源时，他会释放许可，此时Semaphore计数器加1。
• 如果此时有其他线程在等待许可，它将立刻获得许可。

Semaphore使用方式

Semaphore一共有两个构造函数：

Semaphore(int permits)
Semaphore(int permits, boolean fair)

此处peimits用于指定初始许可数，也就是说它代表了同一时刻可以并发访问共享资源的最大线程数，默认情况下Semaphore使用的是非公平锁，通过将fair参数设置为true可以改用公平锁。

下面例子中，我们使用Semaphore来锁定对资源的访问，每个想要使用该资源的线程必须在访问之前先调用acquire()获取锁，当线程使用完毕后，它必须调用release()来释放锁。

// java program to demonstrate
// use of semaphores Locks
import java.util.concurrent.*;

//A shared resource/class.
class Shared
{
	static int count = 0;
}

class MyThread extends Thread
{
	Semaphore sem;
	String threadName;
	public MyThread(Semaphore sem, String threadName)
	{
		super(threadName);
		this.sem = sem;
		this.threadName = threadName;
	}

	@Override
	public void run() {
		
		// run by thread A
		if(this.getName().equals("A"))
		{
			System.out.println("Starting " + threadName);
			try
			{
				// First, get a permit.
				System.out.println(threadName + " is waiting for a permit.");
			
				// acquiring the lock
				sem.acquire();
			
				System.out.println(threadName + " gets a permit.");
		
				// Now, accessing the shared resource.
				// other waiting threads will wait, until this
				// thread release the lock
				for(int i=0; i < 5; i++)
				{
					Shared.count++;
					System.out.println(threadName + ": " + Shared.count);
		
					// Now, allowing a context switch -- if possible.
					// for thread B to execute
					Thread.sleep(10);
				}
			} catch (InterruptedException exc) {
					System.out.println(exc);
				}
		
				// Release the permit.
				System.out.println(threadName + " releases the permit.");
				sem.release();
		}
		
		// run by thread B
		else
		{
			System.out.println("Starting " + threadName);
			try
			{
				// First, get a permit.
				System.out.println(threadName + " is waiting for a permit.");
			
				// acquiring the lock
				sem.acquire();
			
				System.out.println(threadName + " gets a permit.");
		
				// Now, accessing the shared resource.
				// other waiting threads will wait, until this
				// thread release the lock
				for(int i=0; i < 5; i++)
				{
					Shared.count--;
					System.out.println(threadName + ": " + Shared.count);
		
					// Now, allowing a context switch -- if possible.
					// for thread A to execute
					Thread.sleep(10);
				}
			} catch (InterruptedException exc) {
					System.out.println(exc);
				}
				// Release the permit.
				System.out.println(threadName + " releases the permit.");
				sem.release();
		}
	}
}

// Driver class
public class SemaphoreDemo
{
	public static void main(String args[]) throws InterruptedException
	{
		// creating a Semaphore object
		// with number of permits 1
		Semaphore sem = new Semaphore(1);
		
		// creating two threads with name A and B
		// Note that thread A will increment the count
		// and thread B will decrement the count
		MyThread mt1 = new MyThread(sem, "A");
		MyThread mt2 = new MyThread(sem, "B");
		
		// stating threads A and B
		mt1.start();
		mt2.start();
		
		// waiting for threads A and B
		mt1.join();
		mt2.join();
		
		// count will always remain 0 after
		// both threads will complete their execution
		System.out.println("count: " + Shared.count);
	}
}

Output:

Starting A
Starting B
A is waiting for a permit.
B is waiting for a permit.
A gets a permit.
A: 1
A: 2
A: 3
A: 4
A: 5
A releases the permit.
B gets a permit.
B: 4
B: 3
B: 2
B: 1
B: 0
B releases the permit.
count: 0