Java并发编程Semaphore

信号量

信号量类Semaphore，用来保护对唯一共享资源的访问。一个简单的打印队列，并发任务进行打印，加入信号量同时之能有一个线程进行打印任务 。

import java.util.concurrent.Semaphore;

public class PrintQueue {
	public PrintQueue() {

		semaphore = new Semaphore(1,true);
	}

	private final Semaphore semaphore;

	public void printJob(Object document) {
		try {
			semaphore.acquire();

			long duration = (long) (Math.random() * 10);

			System.out.println("执行打印"+Thread.currentThread().getName() + "花费时间"+ duration+ "秒");
			Thread.sleep(duration);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			semaphore.release();
		}
	}
}


public class Job  implements Runnable{

	private PrintQueue printQueue;
	
	public Job(PrintQueue printQueue){
		
		this.printQueue=printQueue;
	}
	@Override
	public void run() {
		printQueue.printJob(new Object());
		System.out.println("文档被打印"+Thread.currentThread().getName());
	}
}

public class Main {
	public static void main(String[] args) {
		PrintQueue p = new PrintQueue();
		Thread thread[] = new Thread[10];
		for (int i = 0; i <thread.length; i++) {
			thread[i]=new Thread(new Job(p),"Thread"+i);
		}
		for (int i = 0; i < thread.length; i++) {
			thread[i].start();
		}
	}
}
----------------------输出结果 ---------------------------
执行打印Thread0花费时间9秒
文档被打印Thread0
执行打印Thread3花费时间9秒
文档被打印Thread3
执行打印Thread2花费时间6秒
文档被打印Thread2
执行打印Thread1花费时间4秒
文档被打印Thread1
执行打印Thread5花费时间6秒
文档被打印Thread5
执行打印Thread7花费时间3秒
文档被打印Thread7
执行打印Thread9花费时间8秒
文档被打印Thread9
执行打印Thread8花费时间0秒
文档被打印Thread8
执行打印Thread6花费时间8秒
文档被打印Thread6
执行打印Thread4花费时间7秒
文档被打印Thread4

如上声明一个打印队列，构造器初始化信号量对象来保护对打印队列的访问。semaphore.acquire();获取信号量，最后semaphore.release();用来释放。启动10个线程进行打印的操作，第一个获得信号量的线程将能访问临界区，其余的线程将被信号量阻塞，直到信号量的释放。信号量被释放后，将选择一个正在等待的线程并且允许它访问临界区。

简单代码分析

    根据boolean fair ，来构建公平和非公平的信号量
    /**
     * Creates a {@code Semaphore} with the given number of
     * permits and the given fairness setting.
     *
     * @param permits the initial number of permits available.
     *        This value may be negative, in which case releases
     *        must occur before any acquires will be granted.
     * @param fair {@code true} if this semaphore will guarantee
     *        first-in first-out granting of permits under contention,
     *        else {@code false}
     */
    public Semaphore(int permits, boolean fair) {
        sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
    }

    FairSync 和 NonfairSync 继承Sync 类，然而Sync 类继承 AbstractQueuedSynchronizer
   /**
     * Synchronization implementation for semaphore.  Uses AQS state
     * to represent permits. Subclassed into fair and nonfair
     * versions.
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 1192457210091910933L;

        Sync(int permits) {
            setState(permits);
        }

        final int getPermits() {
            return getState();
        }

        final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }

        protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                int p = getState();
                if (compareAndSetState(p, p + releases))
                    return true;
            }
        }

        final void reducePermits(int reductions) {
            for (;;) {
                int current = getState();
                int next = current - reductions;
                if (compareAndSetState(current, next))
                    return;
            }
        }

        final int drainPermits() {
            for (;;) {
                int current = getState();
                if (current == 0 || compareAndSetState(current, 0))
                    return current;
            }
        }
    }

参考文献

Java并发编程
AbstractQueuedSynchronizer