名单分派

需求：

最近要实现一个自动派单功能，就是如果有任务来了，那么任务平均分配给现有的员工，如果之前取了任务的员工下次来任务时就分配给下一个，如果有新员工则将员工添加到队列的最后，如果有员工离职就将员工信息从队列里移除。

实现思路：

1. 1.写一个定时任务，定时将任务放入任务队列中TaskQueue，里面存的是任务集合，每个任务里面包含要分派的客户。将所有的员工放入User队列中，如果员工已存在则不添加，如果新员工则加入队列中，如果员工不存在了就从队列中移除。
2. 2.写一个线程，从任务队列中取任务，如果任务不存在则阻塞，取到任务后，将该任务派给下一个员工，并将该员工添加到员工队列末尾，这样达到按员工次序分配任务。
3. 3.实现一个任务队列，如果在取任务时任务不存在则阻塞。
4. 4.实现一个员工队列，在取下一个员工后将该员工从列头移到列尾，并且可以将新员工加入到队列未尾，可以将不存在的员工从队列中移除。

客户类

public class Customer {
    /**
     * 客户id
     */
    private Long id;

    /**
     * 客户名字
     */
    private String userName;
	
	/**
     * 该客户所对应的员工
     */
    private Long taskOwner;
}

员工类

public class UserInfo{
    /**
     * 员工id
     */
    private Long id;
    /**
     * 员工名字
     */
    private String userName;
}

任务队列

public class TaskQueue {
    private static TaskQueue instance;

    private static BlockingQueue<Customer> queue = null;

    private TaskQueue(){
        queue = new LinkedBlockingDeque();
    }

    public static TaskQueue getInstance(){
        if(instance == null){
            instance = new TaskQueue();
        }
        return instance;
    }

    /**
     * 获取队列大小
     * @return
     */
    public static int getSize(){
        return queue.size();
    }

    /**
     * 放入队列中
     */
    public void put(Customer obj){
        if(obj != null){
            try {
                queue.put(obj);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 放入队列中
     */
    public void putAll(List<Customer> objs){
        if(objs != null){
            queue.addAll(objs);
        }
    }

    /**
     * 从队列中取出一个
     * @return
     */
    public Customer take(){
        try {
            Customer obj = queue.take();//当没有任务时task会阻塞
            return obj;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

员工队列：

public class UserQueue {

    private static UserQueue instance = null;
    private static BlockingQueue<UserInfo> queue = null;

    private UserQueue(){
        queue =  new LinkedBlockingDeque<UserInfo>();
    }

    public static UserQueue getInstance(){
        if(instance == null){
            instance = new UserQueue();
        }
        return instance;
    }

    /**
     * 取下一个员工
     * @return
     */
    public UserInfo takeNext(){
        UserInfo userInfo = null;
        try {
            userInfo = queue.take();
            this.put(userInfo);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return userInfo;
    }

    /**
     * 将新员工放入队列中未尾
     */
    public void put(UserInfo userInfo){
        if(queue.contains(userInfo)){
            return;
        }else{
            try {
                queue.put(userInfo);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void putAll(Collection<UserInfo> users){
        for(UserInfo user : users){
            this.put(user);
        }
    }

    /**
     * 将已不存在的员工移除
     */
    public void remove(UserInfo user){
        if(queue.contains(user)){
            queue.remove(user);
        }
    }

    /**
     * 获取目前队列中所有的user
     * @return
     */
    public Object[] getAllUsers(){
        Object[] obj = queue.toArray();
        return obj;
    }
}

名单分派伪代码：

while(true){
	//从任务取出任务
    Customer take = TaskQueue.getInstance().take();
    //取出下一个做坐席员工
	UserInfo userInfo = UserQueue.getInstance().takeNext();
    if(take==null || userInfo==null){
        continue;
    }
    System.out.println(take.getUserName()+"分配给"+userInfo.getUserName());
    //设置该客户所对应的坐席
	take.setTaskOwner(userInfo.getId());
	//保存到数据库
    customerDao.insertCustomer(take);
}

本文摘自：https://blog.csdn.net/yiding123/article/details/84622005