移动到Runnable

Question

我有一些遗留代码，这是从带有main方法的类中调用的，用于强制应用程序关闭并停止所有可能正在运行的删除线程。

private void stopFileDeletionThreads() {
    //as activeCount could be wrong, repeat it until no DeletionThread is found
    boolean bFound = false;
    while (true) {
        bFound = false;
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
        if (tg != null) {
            int count = tg.activeCount();
            Thread[] tArray = new Thread[count];
            tg.enumerate(tArray);
            for (int i = 0; i < count; i++) {
                if (tArray[i].getClass().equals(DeletionThread.class)) {
                    bFound = true;
                    ((DeletionThread) tArray[i]).setRunStatus(false);
                }
            }
        }
        if (!bFound) {
            break;
        }
    }
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        _logger.finest("Ignored interrupted exception when waiting after thread directory removal.");
    }
}

这是DeletionThread：

public class DeletionThread extends Thread {
private File _fDirToDelete;
private boolean _bRun;

/**
 * Constructor.
 * @param fDirToDelete direcotory to remove.
 */
public HsaBrokerDeletionThread(File fDirToDelete) {
    _fDirToDelete = fDirToDelete;
    _bRun = true;
}

/**
 * Thread run method.
 */
public void run() {
    if (_fDirToDelete == null) {
        return;
    }
    if (!_fDirToDelete.exists()) {
        return;
    }
    removeFolders(_fDirToDelete);
}

private void removeFolders(File f) {
    if (f == null) {
        return;
    }
    if (!_bRun) {
        return;
    }
    if (f.isDirectory()) {
        File fChildren[] = f.listFiles();
        if (fChildren != null) {
            for (File fTmp : fChildren) {
                if (!_bRun) {
                    return;
                }
                removeFolders(fTmp);
            }
        }
    }
    f.delete();
}


public void setRunStatus(boolean bRun) {
    _bRun = bRun;
}

启动删除线程的代码在另一个类中：

DeletionThread dt = new DeletionThread(f);
dt.start();

我正在使用ExecutorService和Runnable类，而不是扩展线程。如果上面的代码类似于：

ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.execute(new DirectoryRemover(directory));
executorService.shutdown();

我的疑问是，当应用程序被强制关闭以停止这些删除线程时，如何在stopFileDelectionThreads中复制代码。也许这不是必须的，或者我可以让executor服务与守护进程线程一起工作，但我读到这在使用i/o时不是一个好主意。

另一个想法是，不是每次都在方法中创建一个newSingleThreadExecutor，而是拥有一个可以通过getmethod访问的newCachedThreadPool实例，并在该实例上调用shutdown。然后我就不确定了。

请记住，我不能重写所有的东西，小步骤。谢谢。

Answer 1

我正在使用ExecutorService和Runnable类，而不是扩展

。

实际上，只要代码不做傻事，将extends Thread转换为implements Runnable几乎是微不足道的。

class MyThread extends Thread {

    /**
     * Thread run method.
     */
    public void run() {
        System.out.println("Do something as a Thread.");
    }

}

class MyRunnable implements Runnable {

    /**
     * Thread run method.
     */
    public void run() {
        System.out.println("Do something as a Runnable.");
    }

}

public void test() {
    // Start the `Thread`
    Thread t = new MyThread();
    t.start();
    // Start the `Runnable`.
    Thread r = new Thread(new MyRunnable());
    r.start();
}

我提到的愚蠢的事情包括调用sleep()而不是Thread.sleep()等等，通常可以很容易地解决。

如何转换现有代码以使用Executors这个不那么微不足道的问题实际上需要更多的细节，比如什么触发了DeletionThread的创建。