wątek main a pozostałe wątki

Rejestracja:prawie 11 lat
Ostatnio:prawie 9 lat
Postów:199

0

Cześć :)
Załóżmy, że mamy dwa wątki- wątek główny i w tym wątku odpalamy w sposób następujący:

Kopiuj

ExecutorService exec = Executors.newFixedThreadPool(1);
exec.execute(obiektWatku);

Noi w tym wątku wkładamy pewne rzeczy do wspólnej listy dla tych wątków. Sytuacja wygląda tak, że main() ulega zakończeniu zanim zdąży ten drugi wątek powkładać do listy i przez to main widzi listę pustą. Jak zrobić, żeby widział?
Nie mówię, że musi tak być, żeby w mainie czekać na ten drugi wątek. Nie wiem jak powinno to wyglądać. Normalnie powinno być tak, że ostatnim wątkiem jest main czy też nie? Jeżeli nie to jakoś przeprojektuje program, ale też warto dowiedzieć się jak poczekać na zakończenie innego wątku :)

Qbisiek

2014-06-08 07:26

Qbisiek2014-06-08 07:26

Rejestracja:około 12 lat
Ostatnio:około 10 lat
Postów:160

0

Zrób w mainie pętle, która sprawdza czy wszystkie pozostałe wątki są 'alive', jeżeli już żadnego nie będzie to koniec pętli i koniec głównego wątku.

mućka

2014-06-08 08:49

mućka2014-06-08 08:49

0

A co robi jeszcze ten watek ktory startujesz z maina? Bo jesli tylko wklada nowe watki do listy to mozesz to zrobic w watku main i nie masz problemu.
Jesli musi byc tak jak pokazujesz - aby miec pewnosc, ja bym czekal w watku main na 'zdarzenie' ze wszystkie watki sie znajduja w liscie (wzglednie, jesli sprawdzasz tylko czy chociaz jeden watek tam jest, zdarzeie moze byc generowane po pierwszym wlozeniu watku). Ten drugi watek w opodiwenim momencie (wlozyl 1 lub wiecej watkow do listy) generuje zdarzenie, ktore aktywuje main i ten sobie costam sprawdza.
To 'zdarzenie' mozesz zaimplementowac na bardzo wiele sposobow. Mozesz zrobic zwykle wait/notify, mozesz zrobic za pomoca klas z java.util.concurrent.

Zwykle monitory:

Kopiuj

package test;


import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

    private static List<String> list = new ArrayList<String>();

    private static boolean ready = false;

    public static void main(String[] args) {
        ExecutorService exec = Executors.newFixedThreadPool(1);
        exec.execute(new Runnable() {

            @Override
            public void run() {
                if (new Random().nextBoolean()) {
                    System.out.println("adding element");
                    list.add("some element");
                } else {
                    System.out.println("not adding any element");
                }
                ready = true;
                synchronized (Main.class) {
                    Main.class.notify();
                }
            }
        });

        synchronized (Main.class) {
            while (!ready) { // there might be spurious wakeups and interrupts, needs a loop
                try {
                    Main.class.wait();
                } catch (InterruptedException e) {
                    // ignore, but think about it
                }
            }
        }

        if (list.isEmpty()) {
            System.out.println("empty");
        } else {
            System.out.println("not empty");
        }
    }
}

Monitory z java.util.concurrent:

Kopiuj

package test;


import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Main {

    private static List<String> list = new ArrayList<String>();

    private static boolean ready;

    private static Condition readyCondition;

    public static void main(String[] args) {
        final Lock lock = new ReentrantLock();
        readyCondition = lock.newCondition();
        ExecutorService exec = Executors.newFixedThreadPool(1);
        exec.execute(new Runnable() {

            @Override
            public void run() {
                if (new Random().nextBoolean()) {
                    System.out.println("adding element");
                    list.add("some element");
                } else {
                    System.out.println("not adding any element");
                }
                ready = true;
                lock.lock();
                try {
                    readyCondition.signal();
                } finally {
                    lock.unlock();
                }
            }
        });

        lock.lock();
        try {
            while (!ready) {  // there might be spurious wakeups and interrupts, needs a loop
                readyCondition.await();
            }
        } catch (InterruptedException e) {
            // ignore
        } finally {
            lock.unlock();
        }

        if (list.isEmpty()) {
            System.out.println("empty");
        } else {
            System.out.println("not empty");
        }
    }
}

Struktury java.util.concurrent wyzszego poziomu:

Kopiuj

package test;


import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

    private static List<String> list = new ArrayList<String>();

    private static CyclicBarrier barrier = new CyclicBarrier(2);

    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        ExecutorService exec = Executors.newFixedThreadPool(1);
        exec.execute(new Runnable() {

            @Override
            public void run() {
                if (new Random().nextBoolean()) {
                    System.out.println("adding element");
                    list.add("some element");
                } else {
                    System.out.println("not adding any element");
                }
                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    // ignore
                } catch (BrokenBarrierException e) {
                    // ignore
                }
            }
        });

        barrier.await();

        if (list.isEmpty()) {
            System.out.println("empty");
        } else {
            System.out.println("not empty");
        }
    }
}

To tylko pare przykladow, ktore mozna mnozyc. Nie zakladaj ze obsluga wyjatkow w tym kodzie jest 100% poprawna, tak samo jak to ze niezamykanie executora jest poprawne - zrobilem pare skrotow.

mućka

2014-06-08 08:54

mućka2014-06-08 08:54

0

Petla w drugim przykladzie powinna wygladac raczej tak:

Kopiuj

        try {
            while (!ready) {  // there might be spurious wakeups and interrupts, needs a loop
                try {
                    readyCondition.await();
                } catch (InterruptedException exc) {
                    // ignore
                }
            }
        } finally {
            lock.unlock();
        }

edytowany 1x, ostatnio: bogdans 2016-12-13 17:26

ShookTea 2014-06-08 08:55

<java=code></code> lol.

mućka

2014-06-08 09:01

mućka2014-06-08 09:01

0

Ah jej, naprawde powazny blad. Bys lepiej poprawil jak umiesz.

bogdans 2014-06-08 09:28

@ShookTea chyba nie umie, ja umiem. Btw, jak odpowiadam niezalogowany, to zawsze przed wysłaniem włączam podgląd. Pożyteczny zwyczaj.

ShookTea 2014-06-08 13:19

Nie umiem. Tak się składa, że nie każdy tutaj może edytować posty innych :)

__krzysiek85

2014-06-08 16:23

__krzysiek852014-06-08 16:23

Rejestracja:ponad 18 lat
Ostatnio:ponad 9 lat
Postów:1019

0

W tym celu najlepiej zastosować klasę CountDownLatch - http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CountDownLatch.html

mućka

2014-06-08 21:12

mućka2014-06-08 21:12

0

Jak napisalem mozliwosci jest bardzo duzo, mozna i CDLatch. Mi sie jednak wydaje to dosc skomplikowane, osobiscie bym pierdalnal na notify/wait ;d Ale pan Seliga by znalazl 30 bugow a 30 by nie znalazl...