多线程编程（1）Semaphore 多资源的并发访问

短命女 2022-01-25 17:45 176阅读 0赞

需求，3个打印机，多个打印任务，

要求，如果有打印任务，打印机打印，3个打印机都在调用的时候

其他打印任务等待，打印机任务结束，调用其他排队的打印任务。

打印线程类

public class Job implements Runnable {
        /**
         * 打印队列对象
         */
        private PrintQueue printQueue;
    
        /**
         * 构造函数，初始化打印队列对象
         *
         * @param printQueue 打印队列对象
         */
        public Job(PrintQueue printQueue) {
            this.printQueue = printQueue;
        }
    
        /**
         * 核心方法，向打印队列中发送打印任务，并且等待它完成
         */
        @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());
        }
    }

2，

/**
     * 打印队列对象，它可以访问三台打印机，使用信号量来控制打印机的访问，当有一个打印作业，
     * 如果有空闲的打印杨就将作业分配到某个打印机上，否则就等待打印机空闲，再分配打印机
     */
    public class PrintQueue {
        /**
         * 资源信号量，控制打印机的访问
         */
        private Semaphore semaphore;
        /**
         * 标记打印机是否空闲的数组
         */
        private boolean[] freePrinters;
        /**
         * 锁，控制打印机是否空闲的数组的访问
         */
        private Lock lockPrinters;
    
        /**
         * 构造函数，初始化变量
         */
        public PrintQueue() {
            semaphore = new Semaphore(3); // 资源信号量的个数为3，说明有3个打印机,允许3个线程同时进入
            freePrinters = new boolean[3];
            for (int i = 0; i < freePrinters.length; i++) {
                freePrinters[i] = true;
            }
    
            lockPrinters = new ReentrantLock();
        }
    
        /**
         * 模拟文档打印的方法
         *
         * @param document 需要打印的对象
         */
        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\n", Thread.currentThread().getName(), assignedPrinter, duration);
                TimeUnit.SECONDS.sleep(duration);//模拟打印时间
    
                // 释放打印机
                freePrinters[assignedPrinter] = true;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 释放信号量
                semaphore.release();
            }
        }
    
        /**
         * 获取分配的打印机编号
         * @return   分配的打印机编号
         */
        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;
        }
    }

3，调用测试类

public class Main {
        public static void main(String[] args) {
            // 创建一个打印对队对象
            PrintQueue printQueue = new PrintQueue();
    
            // 创建12个线程，运行作业任务，这些任务都向同一个打印队列对象发出打印请求
            Thread thread[] = new Thread[12];
            for (int i = 0; i < 12; i++) {
                new Thread(new Job(printQueue), "Thread " + i).start();
            }
        }
    }