为什么再次调用 Thread.start 时会出现 IllegalThreadStateException

Question

public class SieveGenerator{

static int N = 50;
public static void main(String args[]){

    int cores = Runtime.getRuntime().availableProcessors();

    int f[] = new int[N];

    //fill array with 0,1,2...f.length
    for(int j=0;j<f.length;j++){
        f[j]=j;
    }

    f[0]=0;f[1]=0;//eliminate these cases

    int p=2;

    removeNonPrime []t = new removeNonPrime[cores];

    for(int i = 0; i < cores; i++){
        t[i] = new removeNonPrime(f,p);
    }

    while(p <= (int)(Math.sqrt(N))){
        t[p%cores].start();//problem here because you cannot start a thread which has already started(IllegalThreadStateException)
        try{
            t[p%cores].join();
        }catch(Exception e){}
        //get the next prime
        p++;
        while(p<=(int)(Math.sqrt(N))&&f[p]==0)p++;
    }


    //count primes
    int total = 0;
    System.out.println();

    for(int j=0; j<f.length;j++){
        if(f[j]!=0){
            total++;
        }
    }
    System.out.printf("Number of primes up to %d = %d",f.length,total);
}
}


class removeNonPrime extends Thread{
int k;
int arr[];

public removeNonPrime(int arr[], int k){
    this.arr = arr;
    this.k = k;
}

public void run(){
    int j = k*k;
    while(j<arr.length){
        if(arr[j]%k == 0)arr[j]=0;
        j=j+arr[k];

    }
}
}

您好，我在运行代码时收到IllegalThreadStateException，我认为这是因为我正在尝试启动一个已经启动的线程。那我怎么杀 还是每次都停止线程，来解决这个问题？

Answer 1

我怎样才能每次都杀死或停止线程来解决这个问题？

答案是，你不能。一旦启动，Thread 可能不会重新启动。这在javadoc for Thread 中有明确记录。相反，您真正想要做的是 new 一个 RemoveNonPrime 的实例，每次您在循环中出现。

您的代码中还有一些其他问题。 首先，您需要在再次使用之前增加p：

for(int i = 0; i < cores; i++){
    t[i] = new removeNonPrime(f,p); //<--- BUG, always using p=2 means only multiples of 2 are cleared
}

其次，你可能是多线程的，但你不是并发的。您拥有的代码基本上一次只允许一个线程运行：

while(p <= (int)(Math.sqrt(N))){
    t[p%cores].start();//
    try{
        t[p%cores].join(); //<--- BUG, only the thread which was just started can be running now
    }catch(Exception e){}
    //get the next prime
    p++;
    while(p<=(int)(Math.sqrt(N))&&f[p]==0)p++;
}

只是我的 0.02 美元，但您尝试执行的操作可能有效，但选择下一个最小素数的逻辑并不总是会选择一个素数，例如，如果其他线程之一尚未处理数组的该部分还没有。

这是一种使用 ExecutorService 的方法，您必须填写一些空白 (...)：

/* A queue to trick the executor into blocking until a Thread is available when offer is called */
public class SpecialSyncQueue<E> extends SynchronousQueue<E> {
    @Override
    public boolean offer(E e) {
        try {
            put(e);
            return true;
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
}

ExecutorService executor = new ThreadPoolExecutor(cores, cores, new SpecialSyncQueue(), ...);
void pruneNonPrimes() {
    //...
    while(p <= (int)(Math.sqrt(N))) {
        executor.execute(new RemoveNonPrime(f, p));
        //get the next prime
        p++;
        while(p<=(int)(Math.sqrt(N))&&f[p]==0)p++;
    }


    //count primes
    int total = 0;
    System.out.println();

    for(int j=0; j<f.length;j++){
        if(f[j]!=0){
            total++;
        }
    }
    System.out.printf("Number of primes up to %d = %d",f.length,total);
}



class RemoveNonPrime extends Runnable {
    int k;
    int arr[];

    public RemoveNonPrime(int arr[], int k){
        this.arr = arr;
        this.k = k;
    }

    public void run(){
        int j = k*k;
        while(j<arr.length){
            if(arr[j]%k == 0)arr[j]=0;
            j+=k;
        }
    }
}

Answer 2

您可以改为实现 Runnable 并使用 new Thread( $Runnable here ).start() 或使用 ExecutorService 来重用线程。

Answer 3

* It is never legal to start a thread more than once.
* In particular, a thread may not be restarted once it has completed
* execution.
*
* @exception IllegalThreadStateException  if the thread was already started
*/
public synchronized void start() {

在 Android 中，文档仍然提到我们会得到IllegalThreadStateException if the thread was already started。
但是对于某些设备，它不会抛出此异常（在 Kyocera 7.0 上测试）。在三星，HTC等一些流行的设备中，它会正常抛出异常

我在这里回答是因为 Android 问题被标记为与此问题重复。

Answer 4

为什么 Thread.start 时会出现 IllegalThreadStateException 再次调用

因为 JDK/JVM 实现者以这种方式编写了 Thread.start() 方法。在线程完成执行后能够重新启动线程是一个合理的功能期望，这就是 chrisbunney 的答案中所建议的（我已经在该答案中发表了评论）但是如果您查看 Thread.start() 实现，第一行是，

if (threadStatus != 0)
            throw new IllegalThreadStateException();

其中threadStatus == 0 表示NEW 状态，所以我的猜测是在执行完成后实现不会将此状态重置为零并且线程留在TERMINATED 状态（非零状态）。因此，当您在同一 Runnable 上创建新的 Thread 实例时，您基本上将此状态重置为零。

此外，我注意到在同一段落中使用了单词 - ma​​y 和 never，因为 Phan Van Linh 在某些操作系统上指出了不同的行为，

多次启动一个线程是不合法的。特别是，一个 线程一旦完成执行就可能不会重新启动。

我猜他们在上面的 Javadoc 中试图说什么，即使你在某些操作系统上没有得到 IllegalThreadStateException，它在 Java/Thread 类方式中也是不合法的，你可能会得到意想不到的行为。

著名的线程状态图描绘了相同的场景 - 不会从死状态返回到新状态。

Answer 5

ThreadPools 可用于传递任务以设置线程数。启动时设置线程数。然后为池添加任务。并且之后您可以阻止，直到所有任务都完成处理。 Here 是一些示例代码。

Answer 6

我完全不确定我是否理解这个问题。所有从其他线程执行的停止线程的方法都已弃用；停止线程的方法是让它检查一个它和另一个线程可以访问的变量（可能是一个 volatile 变量），并让正在运行的线程偶尔检查它，看看它是否应该退出拥有。

我不知道您为什么/是否要消除正在运行的线程并使用另一个线程，而且我看不出不同的线程将如何帮助您更快地执行您的总体目标。但有可能我只是不懂数学。

Answer 7

Thread.isAlive() 方法可以告诉您线程是否已经启动。只需在您想开始线程的地方执行此操作：

   if(!t[p%cores].isAlive()){
       t[p%cores].start();
   }