JAVA：如何模拟并发

Question

I have to create an application which simulates concurrent threads. The "server" creates a number of "threads" and stores them in a queue. Each "thread" has defined a time to finish his execution. The server polls each "thread" from the queue to do his job for 10 ms. If the thread has finished his job, it is removed from the queue. If not, it is added at the end of the queue. I used for this application PriorityQueue. The problem is that the code i wrote is not giving the expected output; a "thread" is executed until his execution time ends. How can I solve this problem?

SimulatedThread class

public class SimulatedThread {

    private int executionTime;
    private Integer id;
    private int executedTime;
    private boolean finished;

    public SimulatedThread(){
       executedTime = 0;
       executionTime = 0;
       setFinished(false);
    }
    //getters and setters
}

Server class

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Random;

public class Server {

final int TIME = 10;
final int TH_NO = 10;

//priority
final int MIN_P = 1;
final int MAX_P = 100;

//execution time
final int MIN_E = 10;
final int MAX_E = 100;

private PriorityQueue<SimulatedThread> activeThreads;



public Server() {
    Comparator<SimulatedThread> comparator = new SimulatedThreadComparator();
    activeThreads = new PriorityQueue<SimulatedThread>(10,comparator);

}

public void createThreads(){
    for( int i = 0; i < TH_NO; i++){
        SimulatedThread th = new SimulatedThread();
        th.setExecutionTime(generator(MAX_E, MIN_E));
        th.setId(generator(MAX_P,MIN_P));
        System.out.println("New thread has been created");
        System.out.println(th.toString());          
        activeThreads.add(th);
    }
}

public void executeThreads(){

    while(!activeThreads.isEmpty()){
        SimulatedThread th = activeThreads.poll();  
        if(!th.isFinished()){

            try {
                Thread.sleep(TIME);
                th.setExecutedTime(th.getExecutedTime() + TIME);
                System.out.println(th.toString());
                if((th.getExecutionTime() - th.getExecutedTime()) <= 0 ){
                    th.setFinished(true);                       
                } else{
                    activeThreads.add(th);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    activeThreads.removeAll(activeThreads);
}

private int generator(int max, int min){
    Random rand = new Random();
    return rand.nextInt((max - min) + 1) - min;
}


public static void main(String[] args){
    Server s = new Server();
    s.createThreads();
    s.executeThreads();
}

EDIT

SimulatedThreadComparator class

import java.util.Comparator;

public class SimulatedThreadComparator implements Comparator<SimulatedThread> {

    @Override
    public int compare(SimulatedThread o1, SimulatedThread o2) {

        return o1.getId().compareTo(o2.getId());
    }
}

Answer 1

That explains it: since the priority is the ID, the last thread that was activated will return to the head of the queue, and be the next activated, until it's finished.

Perhaps you should compare the executed time instead of the ID?