java并发编程学习：用 Semaphore （信号量）控制并发资源

package yjmyzz.lesson01;

import java.util.concurrent.Semaphore;

public class PrintQueue {

    private final Semaphore semaphore;

    public PrintQueue() {
        semaphore = new Semaphore(1);//限定了共享资源只能有1个（相当于只有一把钥匙）
    }

    public void printJob(Object document) {
        try {
            semaphore.acquire();//取得对共享资源的访问权（即拿到了钥匙））

            long duration = (long) (1 + 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();//钥匙用完了，要还回去，这样其它线程才能继续有序的拿到钥匙，访问资源
        }
    }
}

package yjmyzz.lesson01;

public class Job implements Runnable {

    private PrintQueue printQueue;

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

    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());
    }
}

package yjmyzz.lesson01;

public class Main {
    public static void main(String args[]) {

        PrintQueue printQueue = new PrintQueue();

        int threadCount = 3;

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

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

package yjmyzz.lesson01;

public class PrintQueue {

    //private final Semaphore semaphore;

    public PrintQueue() {
        //semaphore = new Semaphore(1);//限定了共享资源只能有1个（相当于只有一把钥匙）
    }

    public void printJob(Object document) {
        try {
            //semaphore.acquire();//取得对共享资源的访问权（即拿到了钥匙））
            long duration = (long) (1 + 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();//钥匙用完了，要还回去，这样其它线程才能继续有序的拿到钥匙，访问资源
        }
    }
}

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

package yjmyzz.lesson02;

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

public class PrintQueue {

    private boolean freePrinters[];//用来存放打印机的状态，true表示空闲，false表示正在打印

    private Lock lockPrinters;//增加了锁，保证多个线程，只能获取得锁，才能查询哪台打印机空闲的

    private final Semaphore semaphore;


    public PrintQueue() {
        int printerNum = 3;//假设有3台打印机
        semaphore = new Semaphore(printerNum);
        freePrinters = new boolean[printerNum];

        for (int i = 0; i < printerNum; i++) {
            freePrinters[i] = true;//初始化时，默认所有打印机都空闲
        }
        lockPrinters = new ReentrantLock();
    }


    private int getPrinter() {
        int ret = -1;
        try {
            lockPrinters.lock();//先加锁，保证1次只能有1个线程来获取空闲的打印机
            for (int i = 0; i < freePrinters.length; i++) {
                //遍历所有打印机的状态，发现有第1个空闲的打印机后，领取号码，
                // 并设置该打印机为繁忙状态（因为马上就要用它）
                if (freePrinters[i]) {
                    ret = i;
                    freePrinters[i] = false;
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //最后别忘记了解锁，这样后面的线程才能上来领号
            lockPrinters.unlock();
        }
        return ret;
    }

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

            int assignedPrinter = getPrinter();//领号
            long duration = (long) (1 + 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 {
            //lockPrinters.lock();//先加锁，保证1次只能有1个线程来获取空闲的打印机
            for (int i = 0; i < freePrinters.length; i++) {
                //遍历所有打印机的状态，发现有第1个空闲的打印机后，领取号码，
                // 并设置该打印机为繁忙状态（因为马上就要用它）
                if (freePrinters[i]) {
                    ret = i;
                    freePrinters[i] = false;
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //最后别忘记了解锁，这样后面的线程才能上来领号
            //lockPrinters.unlock();
        }
        return ret;
    }