0

我正在运行下面的代码 60 分钟，它所做的是每个线程将根据命令是否具有 Previous 使用不同的唯一 ID。如果是Previous，那么它将使用1到1000之间的现有ID，如果不是Previous，那么它将使用5000到10000之间的唯一ID。我编写了这段代码，如果命令有Previous，那么每个线程将使用唯一的ID 在 1 到 1000 之间，如果不是 Previous 则它将使用 5000 到 10000 之间的唯一 ID。

所以问题陈述是这样的-如果命令有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); 
    }
}
4

0 回答 0