最近看了看執行緒池的內容，寫個小程式，標記下，用到了ExecutorService和BlockingQueue

需求，學校組織學生自願驗血，來了三個醫生，抽血速度依次為1000,2000，3000毫秒。

抽血屋子較小，最多能容納9個學生，即排隊，每個醫生最多排3個人。

如果來的學生看到屋子滿了，就離開，不驗了。

先建立學生的一個簡單類，標記不同學生。

Studnet.java

public class Student {
    private int id;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}
 

學生來了之後，先看看屋裡滿了沒，如果慢了，扭頭就走，如果沒滿，找一個人數最少的隊排。

DoctorFactory.java

public class DoctorFactory {
    private static final Object locker=new Object();
    private static final Integer MAX_QUEUE_SIZE=3;
    private static  DoctorFactory doctorFactory=null;
    private Integer doctorCount=3;
    private List<BlockingQueue<Student>> studentQueueList=new ArrayList<>();

    private DoctorFactory()
    {
        ExecutorService executor = Executors.newFixedThreadPool(doctorCount); //執行緒池
        for (int i = 0; i < doctorCount; i++) {
            BlockingQueue<Student> recoDataBlockingQueue = new ArrayBlockingQueue<Student>(MAX_QUEUE_SIZE);
            studentQueueList.add(recoDataBlockingQueue);
            int time=(i+1)*1000;
            executor.execute(new DetectRunnable(Integer.toString(i),time, recoDataBlockingQueue));
        }
        executor.shutdown(); //關閉執行器，不允許繼續提交其它執行緒
    }
    public static DoctorFactory getInstance() {
        if (doctorFactory == null) {
            synchronized (locker) {
                if (doctorFactory == null) {
                    doctorFactory = new DoctorFactory();
                }
            }
        }
        return doctorFactory;
    }

    public boolean putStudentData(Student student) {
        try {
            int pos = findShortQueue();
            BlockingQueue<Student> studentBlockingQueue = studentQueueList.get(pos);
            if (studentBlockingQueue != null) {
                if (studentBlockingQueue.size() >= MAX_QUEUE_SIZE) {
                    System.out.println("student "+ student.getId()+" go");
                    throw new Exception("人數爆了！");
                }
                System.out.println("student "+ student.getId()+" enter "+" dotctor "+pos);
                studentBlockingQueue.put(student);
             }
        } catch (Exception e) {
        }
        return false;
    }

    private int findShortQueue() {
        int pos = 0;
        int size = MAX_QUEUE_SIZE;
        for (int i = 0; i < studentQueueList.size(); i++) {
            BlockingQueue<Student> studentBlockingQueue = studentQueueList.get(i);
            if (studentBlockingQueue != null) {
                if (studentBlockingQueue.size() < size) {
                    size = studentBlockingQueue.size();
                    pos = i;
                }
            }
        }
        return pos;
    }
}
 

DetectRunnable.java

public class DetectRunnable implements Runnable {
    public DetectRunnable(String name,Integer detectTime, BlockingQueue<Student> studentQueue) {
        this.studentQueue = studentQueue;
        this.name = name;
        this.detectTime=detectTime;
    }

    private String name;
    private BlockingQueue<Student> studentQueue;
    private Integer detectTime=1000;
    @Override
    public void run()
    {
        while (true){
            try{
                Student student=studentQueue.take();
                Thread.sleep(detectTime);
                System.out.println("doctor:" + name + " detect student:" + student.getId() +" end time " + detectTime);
            }
            catch(Exception e){}
        }
    }
}
 

    @Test
    public void testThread(){
        DoctorFactory doctorFactory=DoctorFactory.getInstance();
        for(int i=0;i<20;i++)
        {

            Student student=new Student();
            student.setId(i);
            doctorFactory.putStudentData(student);
            try{ Thread.sleep(200);}
            catch (Exception ex){}
        }
        System.out.println("end");
        try{System.in.read();}
        catch (Exception ex){}
    }

student 0 enter  dotctor 0
student 1 enter  dotctor 0
student 2 enter  dotctor 1
student 3 enter  dotctor 1
student 4 enter  dotctor 2
doctor:0 detect student:0 end time 1000
student 5 enter  dotctor 0
student 6 enter  dotctor 2
student 7 enter  dotctor 0
student 8 enter  dotctor 1
student 9 enter  dotctor 2
doctor:0 detect student:1 end time 1000
student 10 enter  dotctor 0
student 11 enter  dotctor 0
doctor:1 detect student:2 end time 2000
student 12 enter  dotctor 1
student 13 enter  dotctor 1
student 14 enter  dotctor 2
doctor:0 detect student:5 end time 1000
student 15 enter  dotctor 0
student 16 go
student 17 go
student 18 go
doctor:2 detect student:4 end time 3000
student 19 enter  dotctor 2
doctor:0 detect student:7 end time 1000
end
doctor:1 detect student:3 end time 2000
doctor:0 detect student:10 end time 1000
doctor:0 detect student:11 end time 1000
doctor:1 detect student:8 end time 2000
doctor:2 detect student:6 end time 3000
doctor:0 detect student:15 end time 1000
doctor:1 detect student:12 end time 2000
doctor:2 detect student:9 end time 3000
doctor:1 detect student:13 end time 2000
doctor:2 detect student:14 end time 3000
doctor:2 detect student:19 end time 3000

每200ms來一個學生，剛開始屋裡沒人，前幾個來的都能很快的排隊，檢查。

到16號時，醫生忙不過來了，就開始有學生離開。

一直到19號，屋裡才有位置，19號入隊檢查。

同時可以看到，醫生檢查速度不同，最後檢查學生的總數也不同，依次為 7，5，5

有三個學生因為排不上隊，離開。