ExecutorService和BlockingQueue的小例子

最近看了看线程池的内容，写个小程序，标记下，用到了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

有三个学生因为排不上队，离开。