Ausführen von Java-Threads sequentiell

Könnten Sie Vollzieher.newSingleThreadExecutor(), aber streng genommen diese startet nur eine Thread, so kann nicht erwartet werden-Lösung.

Die einfachste Lösung mit nur Thread Klasse:

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

(Ich weggelassen Ausnahmebehandlung für Klarheit, Thread.join() werfen kann InterruptedException)

Da dieses eine interview-Frage, Sie sind auf der Suche nach bestimmten Wissens, nicht ein "naja, es ist natürlich besser, es zu tun auf diese Weise" Antwort. Es scheint auch, dass Sie wahrscheinlich strike out-Lösung nach der Lösung, bis Sie die Antwort bekommen, Sie wollen.

Chancen sind Sie wollen, um zu sehen, ob Sie implementieren können, um inter-thread-Kommunikation selbst. Aber Sie wollen nicht Sie, tun Sie es der einfache Weg (thread Referenzen). Ansonsten könnte man nur tun thread.join().

So haben alle drei threads greifen einige bit-shared-memory (synchronized static class). Haben jeden thread überprüfen eine public static int nextThread(). Nach erfolgreicher Vergleich, dass Sie den nächsten thread, Sie sollten Ihre Arbeit tun und update public static setNextThread(int value) mit dem Wert des nächsten thread verarbeitet werden.

Der Schlüssel ist, dies in einem thread-sichere Weise; jedoch, wenn Sie garantieren können einzigartige thread-IDS und sicherstellen, dass keine zwei threads haben den gleichen Bezeichner haben, können Sie (bei sorgfältiger Codierung) selbst zu verwalten, dies zu tun, ohne die Synchronisierung.

Threads ausgeführt werden kann sequenziell durch die Verwendung von ExecutorService. Unten finden Sie Beispiel.

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();
                }
            }
        }
    };
}

Finden Sie alles, was es gibt: http://download.oracle.com/javase/tutorial/essential/concurrency/index.html

Vor allem Lesen Sie über Benachrichtigungen und Synchronisation zwischen threads.

P. S. Und denken Sie daran, auch wenn Sie das interview werden Sie noch arbeiten musste! 🙂

(Ok, ich gebe ein paar Hinweise: sehen Sie die Beschreibung der Methoden wie Object.wait() und Object.notifyAll() es ist die einfachste, aber auch sehr nützliche Mechanismus)

Dies könnte eine Fangfrage. Vielleicht wollen Sie nicht zu hören, die Lösung für dieses spezielle problem, aber wollen Sie zurück zu verfolgen, um die Quelle des Problems und kommen mit einer besseren Lösung.

Ich bin nicht sicher, ob ich verstanden habe die Frage komplett, aber es scheint eine situation, in der wir drucken möchten, werden die threads in der Reihenfolge. Ein Beispiel ist der Druck, den Wert, die Verwendung von threads in einer Sequenz wie:

Thread - 0 Ausgabe: 1

Thread - 1 Leistung: 2

Thread - 2 Ausgabe: 3

Thread - 0 Ausgabe: 4

Thread - 1 Leistung: 5

Thread - 2-Ausgabe: 6 und so weiter..

Wenn dies der Anforderung eine generische Lösung für n threads geschrieben werden kann, wo jeder thread wartet, bis Ihr dran (mit gemeinsamen Objekt, auf das er wird versuchen, die Sperre).

class ResourceLock {
    private volatile int currentThreadId;
    private final int totalThreads;

    public ResourceLock(int threadsCount) {
        this.currentThreadId = 0;
        this.totalThreads = threadsCount;
    }
    public void assignTokenToNextThread(int currentThreadNum) {
        this.currentThreadId = (currentThreadNum + 1) % totalThreads;
    }
    public int getCurrentThreadId() {
        return currentThreadId;
    }
}

Nun ein worker-thread wird seinen job tun, und verwenden Sie die Instanz der obigen Klasse für die Verriegelung Zweck:

class Worker extends Thread {
    private final ResourceLock resourceLock;
    private final int threadId;                     //id of this thread
    private final AtomicInteger counter;            //counter shared by all threads, will print number in sequence.
    private volatile boolean running = true;        //flag to stop this thread when necessary
    public Worker(ResourceLock resourceLock, int threadNumber, AtomicInteger counter) {
        this.resourceLock = resourceLock;
        this.threadId = threadNumber;
        this.counter = counter;
    }
    @Override
    public void run() {
        while (running) {
            try {
                synchronized (resourceLock) {
                    while (resourceLock.getCurrentThreadId() != this.threadId) {
                        resourceLock.wait();
                    }
                    System.out.println("Thread:" + threadId + " value: " + counter.incrementAndGet());
                    Thread.sleep(1000);
                    resourceLock.assignTokenToNextThread(this.threadId);
                    resourceLock.notifyAll();
                }
            } catch (Exception e) {
                System.out.println("Exception: " + e);
            }
        }
    }
    public void shutdown() {
        running = false;
    }
}

Und dies kann getestet werden, wie:

public static void main(String[] args) throws InterruptedException {
        final int threadsCount = 3;
        final ResourceLock lock = new ResourceLock(threadsCount);
        Worker[] threads = new Worker[threadsCount];
        final AtomicInteger counter = new AtomicInteger(0);
        for(int i=0; i<threadsCount; i++) {
            threads[i] = new Worker(lock, i, counter);
            threads[i].start();
        }
        Thread.sleep(20000);
        System.out.println("Will try to shutdown now...");
        for(Worker worker: threads) {
            worker.shutdown();
        }
    }