Почему Java Thread спроектирован таким образом, что его нельзя перезапустить? [Дубликат]

Если вы обеспокоены накладными расходами на создание нового объекта Thread, вы можете использовать исполнители.

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
public class Testes {
    public static void main(String[] args) {
        Executor executor = Executors.newSingleThreadExecutor();
        executor.execute(new Testes.A());
        executor.execute(new Testes.A());
        executor.execute(new Testes.A());
    }   
    public static class A implements Runnable{      
        public void run(){          
            System.out.println(Thread.currentThread().getId());
        }
    }
}

Запустив это, вы увидите, что тот же поток используется для всех объектов Runnable.

A Thread не является нитью . Нить - это исполнение вашего кода. Thread - это объект, который ваша программа использует для создания и управления жизненным циклом потока .

Предположим, вам нравится играть в теннис. Предположим, вы и ваш друг играете в действительно потрясающий набор. Как бы ваш друг отреагировал, если бы вы сказали: «Это было невероятно, давайте снова сыграем». Ваш друг может подумать, что вы с ума сошли. Не имеет смысла даже говорить о том, чтобы снова играть в один и тот же набор. Если вы снова играете, вы играете в другой набор.

Нить - это исполнение вашего кода. Не имеет смысла даже говорить о «повторном использовании» потока исполнения по той же причине, что бессмысленно говорить о повторном воспроизведении того же набора в теннисе. Даже если другое выполнение вашего кода выполняет все те же операторы в том же порядке, это все еще исполнение .

Анджей Дойл спросил: «Почему вы хотите для повторного использования Thread? " Почему? Если объект Thread представляет поток выполнения --- эфемерная вещь, о которой вы даже не можете говорить о повторном использовании, то зачем вам или ожидать объект Thread для повторного использования?

Вы можете обойти это, либо используя java.util.concurrent.ThreadPoolExecutor, либо вручную, имея поток, который вызывает Runnable.run() для каждого Runnable, который ему задан, а не фактически выходит, когда он закончен.

Это не совсем то, о чем вы спрашивали, но если вы беспокоитесь о времени строительства нити, это может помочь решить эту проблему. Вот пример кода для ручного метода:

public class ReusableThread extends Thread {
    private Queue<Runnable> runnables = new LinkedList<Runnable>();
    private boolean running;

    public void run() {
        running = true;
        while (running) {
            Runnable r;
            try {
                synchronized (runnables) {
                    while (runnables.isEmpty()) runnables.wait();
                    r = runnables.poll();
                }
            }
            catch (InterruptedException ie) {
                // Ignore it
            }

            if (r != null) {
                r.run();
            }
        }
    }

    public void stopProcessing() {
        running = false;
        synchronized (runnables) {
            runnables.notify();
        }
    }

    public void addTask(Runnable r) {
        synchronized (runnables) {
            runnables.add(r);
            runnables.notify();
        }
    }
}

Очевидно, это просто пример. Он должен иметь лучший код обработки ошибок и, возможно, больше настроек.

Потому что они не создали его таким образом. С ясной точки зрения это имеет смысл для меня. Thread представляет поток выполнения, а не задачу. Когда эта последовательность выполнения завершена, она выполнила свою работу, и она просто замалчивала все, чтобы она начиналась сверху.

С другой стороны, Runnable представляет задачу и может быть передана многим Потоки столько раз, сколько хотите.

Почему вы не хотите создавать новую тему? Если вы обеспокоены накладными расходами на создание своего объекта MyThread, сделайте его Runnable и запустите его с помощью new Thread(myThread).start();