线程不会死，其中两个一直重叠

Question

我需要一个一次只运行一次的线程，例如，如果它第一次被调用，它将运行，如果它被第二次调用，第一次应该完全停止并被允许死掉，然后一个新的应该取而代之。 我进行了一个小测试，看看每次执行之间实际发生了什么，结果表明线程没有死，而是两个线程同时执行：

public class Test {
    Worker worker = new Worker();

    @Override
    public void valid() {

        try {
            if (worker.running) {
                worker.running = false;
                worker.join();
            }

        } catch (InterruptedException iex) {
            worker.running = false;
        }

        worker = new Worker();

        worker.start();

    }

    private final class Worker extends Thread {
        private volatile boolean running = true;

        @Override
        public void run() {
            while (running) {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException iex) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
}

结果如下：

//Upon first execution
Thread-4
Thread-4
Thread-4
Thread-4

//When I execute it again
Thread-7
Thread-4
Thread-7
Thread-4
Thread-7
Thread-4

我尝试使用ExecutorService 或while(!Thread.currentThread.isInterrupted) 代替布尔标志，并得到相同的结果。 如何正确停止“Thread-4”并只运行其中一个？

实际问题来自一个线程，该线程将循环遍历列表并根据请求更新不和谐聊天中的内容，线程所做的是根据肾脏的建议收听输入和更改我正在尝试使用 executor.submit()和未来

private ExecutorService executor = Executors.newSingleThreadExecutor();

    private Future<Void> worker;

    private void setupImageThread() {

        if (!worker.isDone() && !worker.isCancelled()) {
            worker.cancel(true);
        }

        this.worker = (Future<Void>)executor.submit(new Cycler(Listener.queue(), this.links, Cel.cMember()));

        ScheduledExecutorService ses = Executors.newScheduledThreadPool(1);

        Runnable timeout = () -> {

            executor.shutdown();

        };

        ses.schedule(timeout, 100, TimeUnit.SECONDS);
    }

如何在 Future 第一次创建时对其进行初始化？

Answer 1

使用single thread executor service，我会尝试这样的事情：

public class Test {

    private static ExecutorService executor = Executors.newSingleThreadExecutor();

    Future<Void> worker;

    public Test() {
        this.worker = executor.submit(new Worker());
    }

    @Override
    public void valid() {
        if (!worker.isDone() && !worker.isCancelled()) {
            worker.cancel(true);  // Depends on whether you want to interrupt or not
        }

        this.worker = executor.submit(new Worker());
    }
}

并使Worker实现Runnable。

Answer 2

看来valid方法可以同时调用多次。这意味着，这些调用中的每一个都将等待一个线程（Worker）结束，而它们中的每一个都会创建自己的Worker，并且您会丢失指向它的指针，因此无法阻止一堆新创建的工作者。 您应该使 valid 方法同步：synchronized void valid() 它将阻止创建许多工作人员：

@Override
synchronized public void valid() {
    ...
}

还有一点要说。您将while循环放在try-catch之外，这是错误的：如果tread被中断，中断不会杀死它，因为下一个interation开始了，所以应该是这样的：

@Override
public void run() {
    try {
        while (running) {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(2000);
        }
    catch (InterruptedException iex) {
       //you don't need here Thread.currentThread().interrupt() call, because the thread has alredy been interrupted. 
       // The return statement here is also obsolete, I just use it as an example, but you can use empty braces.
       return; 
    }
    }
}