java semaphore

java基于semaphore方式实现对资源的并发访问，也是多线程同步的一种方式，它一般是用于实现对多个资源副本的并发访问控制，而synchronized，lock等同步方式不同则用于针对一个资源的并发访问控制，也就是说资源只允许一个线程同时访问，而semaphore则可以控制某几个线程同时访问资源。
当然semaphore它也有一个变种，即二进制信号量，它的作用实际上和synchronized和lock就差不多了，二进制信号量也是限制资源只允许一个线程同时访问。
具体的内容可以参考下面的例子。

package com.basic.thread;

import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BasicSemaphore {
    public static void main(String args[]) {
        PrintQueueSem pq = new PrintQueueSem();
        Thread thread[] = new Thread[10];

        for (int i=0; i<10; i++) {
            thread[i] = new Thread(new Job(pq), "Thread" + i);
        }

        for (int i=0; i<10; i++) {
            thread[i].start();
        }
    }
}

class PrintQueue {
    private final Semaphore semaphore;

    public PrintQueue() {
        semaphore = new Semaphore(1);
    }

    public void printJob(Object doc) {
        try {
            semaphore.acquire();
            long duration = (long) (Math.random()*10);
            System.out.printf("%s: PrintQueue: Printing a Job during %d seconds\n",Thread.currentThread().getName(),duration);
            Thread.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

class PrintQueueSem {
    private boolean freePrinters[];
    private Lock lockPrinter;
    private final Semaphore semaphore;

    public PrintQueueSem() {
        semaphore = new Semaphore(3);

        freePrinters = new boolean[3];
        for (int i = 0; i < 3; i++) {
            freePrinters[i] = true;
        }
        lockPrinter = new ReentrantLock();
    }

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

            int assignedPrinter = getPrinter();

            long duration = (long) (Math.random()*10);
            System.out.printf("%s: PrintQueue: Printing a Job in Printer%d during %d seconds\n",Thread.currentThread().getName(), assignedPrinter,duration);
            Thread.sleep(duration);
            freePrinters[assignedPrinter] = true;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }

    private int getPrinter() {
        int ret = -1;
        try {
            lockPrinter.lock();
            for (int i=0; i<freePrinters.length; i++) {
                if (freePrinters[i]) {
                    ret = i;
                    freePrinters[i]=false;
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lockPrinter.unlock();
        }

        return ret;
    }
}

class Job implements Runnable {
    /**
    private PrintQueue printQueue;
    public Job(PrintQueueSem pq) {
        this.printQueue = pq;
    }
    */

    private PrintQueueSem printQueue;
    public Job(PrintQueueSem pq) {
        this.printQueue = pq;
    }

    @Override
    public void run() {
        System.out.printf("%s: Going to print a job\n",Thread. currentThread().getName());
        printQueue.printJob(new Object());
        System.out.printf("%s: The document has been printed\n",Thread.currentThread().getName());
    }

}