IT工程師數位筆記本

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