JAva Semaphore信号量の使い方

スレッドが共有リソースにアクセスする場合は、まず信号量を取得する必要があります.信号量の内部カウンタが0より大きい場合、信号量は1減少し、この共有リソースへのアクセスを許可する.カウンタが0より大きいと、使用可能なリソースがあり、スレッドが1つのリソースを使用できることを意味します.
そうでなければ、信号量のカウンタが0に等しい場合、信号量はカウンタが0より大きいまでスレッドをスリープさせ、カウンタが0に等しい場合、すべての共有リソースが他のスレッドで使用されていることを意味するので、この共有リソースにアクセスする必要があるスレッドは待たなければならない.
スレッドが共有リソースを使用し終わると、信号量は解放され、他のスレッドが共有リソースにアクセスできるようにしなければならない.レリーズ操作により信号量の内部カウンタが1増加します.
アセット:印刷キューいんさつキュー

import java.util.concurrent.Semaphore;

/**
 * Created by Administrator.
 */
public class PrintQueue {
    private final Semaphore semaphore;

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

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

Runnable job:

public class Job implements Runnable {
    private PrintQueue printQueue;

    public Job(PrintQueue printQueue){
        this.printQueue=printQueue;
    }

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

Main:

public class Main {
    public static void main(String args[]){
        PrintQueue printQueue = new PrintQueue();
        Thread thread[] = new Thread[10];
        for(int i=0; i<10; i++){
            thread[i] = new Thread(new Job(printQueue), "Thread " + i);
        }

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

1つのリソースの複数のコピーを信号量で保護します.

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

/**
 * Created by Administrator.
 */
public class PrintQueue {
    private final Semaphore semaphore;
    private boolean freePrinters[];
    private Lock lockPrinters;

    public PrintQueue(){
        semaphore = new Semaphore(3);
        freePrinters=new boolean[3];

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

        lockPrinters=new ReentrantLock();
    }

    public void printJob(Object document){
        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
", Thread.currentThread()
            .getName(), assignedPrinter, duration
            );
            TimeUnit.SECONDS.sleep(duration);
            freePrinters[assignedPrinter]=true;
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            semaphore.release();
            System.out.printf("%s: Done the print job
", Thread.currentThread().getName());
        }
    }

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

        return ret;
    }
}