基于多线程的自动派单系统设计

1. 司机队伍对象

public class DriverQueue {

    // 空闲司机队伍
    private static Map<Integer, Driver> freeDrivers = new ConcurrentHashMap<>();

    // 等待（派单中）司机队伍
    private static Map<Integer, Driver> waitDrivers = new ConcurrentHashMap<>();

    // 忙碌（已接单）司机队伍
    private static Map<Integer, Driver> busyDrivers = new ConcurrentHashMap<>();
}

2. 任务队列

/**
 * 任务队列
 * 如果在取任务时没有任务，则阻塞
 * @author LiLongjian
 *
 */
public class TaskQueue {

    private static TaskQueue instance;

    private static BlockingQueue<DispatchRecord> queue = null;

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

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

    public boolean contain(int customerId) {
        for (DispatchRecord record : queue) {
            if (record.getCustomerId() == customerId) {
                return true;
            }
        }
        return false;
    }

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

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

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

    /**
     * 从队列中取出一个
     * @return
     */
    public DispatchRecord take(){
        try {
            return queue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }

}

3. 自动派单（任务分派）主线程：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.text.ParseException;
import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.FutureTask;

/**
 * 从任务队列里取到任务