Java Wielowątkowość

Dzień doby, mam zadanie: zrobić trzy wątki i każdy będzie miał metodę do wykonania w run.
Jak zrobić tak, żeby wątki zaczynały swoją pracę krok po kroku, a nie wszystkie naraz? : Pierwszy wątek zaczał i skończył swoją pracę, potem zaczyna działać inny.
Dziękuję

class Main {
...
...
...
...
        FirstThread first = new FirstThread(array);
        SecondThread second = new SecondThread(array);
        ThirdThread third = new ThirdThread();

        first.start();
        second.start();
        third.start();

    }
}

class FirstThread extends Thread{
    int array[];

    public FirstThread(int array[]){
        this.array = array;
    }
    private synchronized int first_sum(int[] array, int idx) {
        if (idx < array.length - 1)
            return array[idx] + first_sum(array, idx + 1);
        return array[idx];
    }

    @Override
    public void run() {
        System.out.println("\nExercise #1");
        System.out.println(first_sum(array, 0));
    }
}

Problem jest trochę wydumany, ponieważ po to tworzymy wątki, żeby wykonywać kod równolegle, a co za tym idzie - współbieżnie.

Jeśli rzeczywiście musisz zrobić tak jak piszesz, to albo:

1. Nie potrzebujesz wątków, po prostu wykonaj operacje sekwencyjnie.
2. ALBO zrób te wątki i użyj metody Thread#join()

Jeżeli wykona zadania sekwencyjnie (bez wątków) to może zablokować wątek główny aplikacji.

Można zrobić ThreadPollem, albo po każdym wątku dawać joina (XD). Jest jeszcze trzeci sposób, zrób jakiegoś MUTEX'a i blok synchronized.

Jeszcze jest Executors.newSingleThreadExecutori(); :D

Władyslaw Parchomenko napisał(a):

Jak zrobić tak, żeby wątki zaczynały swoją pracę krok po kroku, a nie wszystkie naraz? : Pierwszy wątek zaczał i skończył swoją pracę, potem zaczyna działać inny.

Jednym z głównych problemów zaczynających naukę programowania jest to, że nie potrafią sprecyzować problemu. Dlaczego i po co chcesz to zrobić? Bo tak się nie powinno robić.

Gdyby to była aplikacja okienkowa to uruchomienie tego kodu sekwencyjnie(bez wątków) mogłoby zablokować całe okno. W czasach procesorów wielordzeniowych problemy obliczeniowe należy zrównoleglić albo przekazać do osobnych wątków.

Collection<Integer> elems = new LinkedList<Integer>();
for (int i = 0; i < 40; ++i) {
    elems.add(i);
}
Parallel.For(elems, 
 new Parallel.Operation<Integer>() {
    public void perform(Integer param) {
        System.out.println(param);
    };
});

W ramach ćwiczeń wstawiam rozwiązanie oparte o Thread, Runnable i AtomicInteger poniżej.
Nie jest może najpiękniejsze, ale wygląda na to, że działa.

package com.company;

import java.util.concurrent.atomic.AtomicInteger;

public class Main {

    private static final AtomicInteger whichOne = new AtomicInteger(0);

    public static void main(String[] args) throws Exception {
        class MyThread extends Thread {

            public MyThread(Runnable target, int requiredSequenceId) {
                super(target, String.valueOf(requiredSequenceId));
            }

            @Override
            public void run() {
                int id = Integer.valueOf(Thread.currentThread().getName());
                while (!whichOne.compareAndSet(id, id + 1)) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                super.run();
                whichOne.compareAndSet(id + 1, id + 2);
            }
        }

        class MyRunnable implements Runnable {

            private final int workId;

            public MyRunnable(int workId) {
                this.workId = workId;
            }

            public void run() {
                System.out.println("Step with id = " + workId + " performed");
            }
        }

        Thread t1 = new MyThread(new MyRunnable(1), 0);
        Thread t2 = new MyThread(new MyRunnable(2), 2);
        Thread t3 = new MyThread(new MyRunnable(3), 4);

        t3.start();
        t1.start();
        t2.start();

        Thread.sleep(100);
    }
}

Wynik:

Step with id = 1 performed
Step with id = 2 performed
Step with id = 3 performed

Process finished with exit code 0