Question

我运行以下代码60分钟，它正在做的是每个线程将使用不同的唯一ID基于命令是否具有上一个。如果它是Previous，那么它将使用介于1和1000之间的现有ID，如果它不是Previous，那么它将使用介于5000和10000之间的唯一ID。我写了这个代码，其中If命令有Previous，那么每个线程将使用唯一ID介于1和1000之间，如果不是Previous，则它将使用介于5000和10000之间的唯一ID。

所以问题陈述是这样的 - 如果command具有Previous，则每个线程将使用1到1000之间的唯一ID 如果它不是Previous，则每个线程将使用5000到10000之间的唯一ID

我的问题是 - 1）这是正确的方法吗？或者什么是最好的方式 2）其次这非常慢，有时会停止，并且在这些数字之间不使用任何唯一ID。如果id已完成，我还需要重复使用id

class IdPool {
    private final LinkedList<Integer> availableExistingIds = new LinkedList<Integer>();
    private final LinkedList<Integer> availableNewIds = new LinkedList<Integer>();

    public IdPool() {
        for (int i = 1; i <= 1000; i++) {
            availableExistingIds.add(i);
        }

        for (int k = 5000; k <=10000; k++) {
            availableNewIds.add(k);
        }
    }

    public synchronized Integer getNewId() {
        return availableNewIds.removeFirst();
    }

    public synchronized void releaseNewId(Integer id) {
        availableNewIds.add(id);
    }

    public synchronized Integer getExistingId() {
        return availableExistingIds.removeFirst();
    }

    public synchronized void releaseExistingId(Integer id) {
        availableExistingIds.add(id);
    }
}


class ThreadNewTask implements Runnable {
    private IdPool idPool;
    private Command command;

    public ThreadNewTask(IdPool idPool, Command cmd) {
        this.idPool = idPool;
        this.command = cmd;
    }

    public void run() {
        if(command.getDataCriteria().equals("Previous")) {
            Integer id = idPool.getExistingId();
            newMethod(id);
            idPool.releaseExistingId(id);
        } else {
            Integer newId = idPool.getNewId();
            newMethod(newId);
            idPool.releaseExistingId(newId);
        }

    }

    private void newMethod(Integer i) {
        System.out.println("Task ID: " +i);

    }
}

public class TestingPool {
    public static void main(String[] args) throws InterruptedException {
        int size = 10;
        int durationOfRun = 60;
        IdPool idPool = new IdPool();   
        // create thread pool with given size
        ExecutorService service = Executors.newFixedThreadPool(size); 

        // queue some tasks
        long startTime = System.currentTimeMillis();
        long endTime = startTime + (durationOfRun * 60 * 1000L);

        // Running it for 60 minutes
        while(System.currentTimeMillis() <= endTime) {
            Command nextCommand = getNextCommandToExecute();
            service.submit(new ThreadNewTask(idPool, nextCommand));
        }

        // wait for termination        
        service.shutdown();
        service.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS); 
    }
}

每个线程的唯一编号

0 个答案: