线程如何已经启动？

Question

我有一个单实例线程类。

public class LogThread extends Thread{

    private static LogThread instance = null;
    private volatile boolean isRunning = false;
    private final static Object instanceLock = new Object();

    public static synchronized LogThread getInstance(){
        synchronized(instanceLock){
            if(instance == null)
                instance = new LogThread();
        }
        return instance;
    }

    @Override
    public run(){
        //Doing some run stuff
        //Once run is finished

        synchronized(instanceLock){
            isRunning = false;
            instance = null;
        }
    }

    @Override
    public synchronized void start() {
        synchronized (instanceLock){
            if(!isRunning){
                isRunning = true;
                super.start();
            }
        }
    }
}

每次获取实例时，我都会从另一个线程调用 start，并且每隔一段时间，我会在 com.......LogThread.start 中收到 IllegalThreadStateException，第 x 行线程已经启动。

如果我在启动线程之前设置了 isRunning 并基于 instanceLock 同步它，如何启动线程。

编辑:: 我已将我的 getInstance() 编辑到以下：

 public static synchronized LogThread getInstance(){
     synchronized(instanceLock){
         if(instance == null){
             instance = new LogThread();
             instance.start();
         }
     }
 }

它应该停止任何尝试启动已经启动的线程。

Answer 1

顺序是这样的：

• 线程 A 调用 getInstance。线程 A 锁定了一段时间，是时候检查instance 是否不为空，此时它不是。
• 线程 LogThread 完成执行，isRunning 设置为 false。 instance 设置为 false，但仍被线程 A 保留
• 线程 A 在实例上调用 start。 isRunning 为 false，因此会调用 start，从而导致崩溃。

一个快速的解决方法是不要将isRunning 设置为false，因为没有任何充分的理由让该实例可以重新启动。然后应将其重命名为 isStarted 以与其所做的保持一致。

按照@Mani 的建议，一个合适的解决方案是使用newSingleThreadExecutor

Answer 2

It is never legal to start a thread more than once.
     * In particular, a thread may not be restarted once it has completed
     * execution.

来自Thread.start

您不应该启动已经启动的线程。即使线程完成了它的工作（运行完成）。

它只是检查threadStatus 并抛出异常

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

如果我理解清楚，您希望确保只有一个线程用于此任务，并且您希望重用同一个线程。 恕我直言，你有两个选择，

选项 1：每次都创建新线程。确保前一个线程完成了它的工作。它很昂贵，因为每次创建新线程都很昂贵

选项 2：Executors.newSingleThreadExecutor() 使用它。这将确保只创建一个线程。

一般来说，避免扩展线程，使用Runnable。

如果你只想使用一个线程。并且有很多工作。您可以使用以下内容。

class LogJob implements Runnable{
    @Override
    public void run() {
        // Do your Job
    }
}

  ExecutorService singleThread = Executors.newSingleThreadExecutor();
LogJob job = new LogJob();
for (int i=0;i<100;i++){
    singleThread.submit(job);
}
singleThread.shutdown();

// 对于演示，我已将其置于循环中。你可以打电话给singleThread.submit(job);。在任何给定时间最多只能运行一个作业。你所有的工作都将完成。

您不需要任何同步块/方法