Последовательно запускать потоки Java

Как вы будете выполнять три потока последовательно? Для EG. Thread1, Thread2, Thread3. Невозможно передать ссылку одного потока на другой и вызвать из метода run ().

поэтому код должен быть такой:

 Thread1.start();
 Thread2.start();
 Thread3.start();

а out put должен быть

 Printing Thread1
 Printing Thread2
 Printing Thread3

Это может быть возможно с помощью ThreadPoolExecutor и с помощью очереди блокировки, но даже это не является приемлемым ответом.

8
concurrency java java.util.concurrent multithreading

7 ответов

использовать ExecutorService на java.утиль.concurrent пакет. Точнее используйте Executors.newSingleThreadExecutor();

10

вы могли бы использовать исполнителей.newSingleThreadExecutor (), но строго говоря, это запускает только один Thread, поэтому не может быть ожидаемое решение.

самое простое решение, используя только Thread класс:

Thread1.start();
Thread1.join();
Thread2.start();
Thread2.join();
Thread3.start();
Thread3.join();

(Я опустил обработку исключений для ясности,Thread.join() можете кинуть InterruptedException)

15

самый простой ответ

Thread1.run();
Thread2.run();
Thread3.run();

проблема с нереалистичными вопросами заключается в том, что они часто имеют неинформативный ответ. ;)

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

вы можете сказать это; вы не можете вызвать метод run (), в этом случае вы не можете использовать ThreadPoolExecutor, потому что он вызывает метод run () для вас. т. е. это то, что submit() в конечном итоге делает.

EDIT: результаты полностью детерминированы, потому что тот факт, что есть поток, является нерелевантным.

static class PrintThread extends Thread {
    public PrintThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++)
            System.out.println(getName() + ": " + i);
    }
}

public static void main(String args[]) {
    Thread thread1 = new PrintThread("A");
    Thread thread2 = new PrintThread("B");
    Thread thread3 = new PrintThread("C");

    thread1.run();
    thread2.run();
    thread3.run();
}

печать

A: 0
A: 1
.. deleted ..
C: 98
C: 99

как и ожидалось.

10

поскольку это вопрос интервью, они ищут конкретные знания, а не "ну, очевидно, лучше сделать это таким образом" ответ. Также кажется, что они, скорее всего, будут вычеркивать решение за решением, пока не получат ответ, который они хотят.

скорее всего, они хотят посмотреть, можете ли вы реализовать межпоточные коммуникации самостоятельно. Но они не хотят, чтобы вы делали это простым способом (ссылки на потоки доступны). В противном случае, вы могли бы просто сделать thread.join().

Так попросите все три потока захватить некоторый бит общей памяти (синхронизированный статический класс). У каждого потока проверьте public static int nextThread(). После успешного сравнения, что они являются следующим потоком, они должны выполнять свою работу и обновлять public static setNextThread(int value) со значением следующего обрабатываемого потока.

ключ должен сделать это потокобезопасным способом; однако, если вы можете гарантировать уникальные идентификаторы потоков и гарантировать, что никакие два потока не имеют одного и того же идентификатора ,вы можете (с тщательным кодированием) даже управлять сделайте это без синхронизации.

4

Если бы это не было связано с различными способами вызова этих потоков, теоретически, они должны использовать приобрести общий sempahore, и отпустите его, когда закончите печать.
Комплект JDK имеет встроенный семафор.

4

потоки могут выполняться последовательно с помощью ExecutorService. Ниже приведен пример.

public class SeqThread {

    public static void main(String[] arg) {
          new SeqThread().execute();
    }

    public void execute() {
        try {
        ExecutorService executor = Executors.newFixedThreadPool(1);
        executor.submit(R);
        executor.submit(R2);
        executor.shutdown();

            executor.awaitTermination(10, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    Runnable R = new Runnable() {

        @Override
        public void run() {
            // TODO Auto-generated method stub
            for(int i=0;i<10;i++)
            {
                System.out.println("In Thread One "+i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    };

    Runnable R2 = new Runnable() {

        @Override
        public void run() {
            // TODO Auto-generated method stub
            for(int i=0;i<10;i++)
            {
                System.out.println("In Thread Two="+i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    };
}
4

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

2