[JAVA] Wątki - równoległe wykonywanie 2 wątków

0

Witam. Próbuję stworzyć program wykorzystujący obsługę wątków w Java. Program powinien szukać klucza szyfrującego poprzez brutalny atak.
Przykład.
mam ciąg wejściowy : 1234
klucz: 2223
ciąg wyjściowy : 3457
algorytm szyfrujący to po prostu dodawanie czyli 1234+2223 = 3457.
I teraz chcę aby: jeden wątek sprawdzał klucze od 0 do 5000, a drugi od 5000 do 10000.
Proszę o pomoc. Bo to moje pierwsze doświadczenie z wątkami. Albo proszę o jakiś przykład jak wykonywać wątki równolegle. Z góry dzięki

0

hoho, watki to obszerny dzial.
Musisz wiedziec jak dziala klasa Thread i interfejs Runnable. metody start(), join(), sleep(), wait(). Musisz tez wiedziec cos o programowaniu wspolbieznym synchronizacji watkow (Semaphore, synchronized, ReentraintLock, Contition)
poszukaj jakiegos tutoriala.
pozdrawiam

0

Proponuję zapoznać się z:
-klasą Thread
-czymś do przekazywania rezultatów, np. ConcurrentLinkedQueue
-czymś do wieszania wątku głównego, np. CountDownLatch

Poniżej przedstawiam przykładową implementację:
-obiekt klasy ThreadsMain tworzy i uruchamia workerCount wątków Worker przydzielając im po workPerWorker pracy, następnie czeka na finishCounter, aż skończą i wypisuje wyniki z results
-Worker dostaje w konstruktorze zakres, który ma obrobić(begin, end). W run() szuka odpowiedzi i wpisuje ją/je na listę results. Na końcu obniża finishCounter o jeden. Gdy finishCounter spadnie do zera ThreadsMain będzie mógł kontynuować.

package threads;

import java.util.concurrent.*;

public class ThreadsMain {

    final static int workerCount = 2;
    final static int workPerWorker = 5000;

    CountDownLatch finishCounter = new CountDownLatch(workerCount);
    ConcurrentLinkedQueue<Integer> results = new ConcurrentLinkedQueue<Integer>();

    Worker[] workers = new Worker[workerCount];

    ThreadsMain() {
        /* make and start workers */
        for (int i = 0; i < workerCount; i++) {
            workers[i] = new Worker(i * workPerWorker, (i + 1) * workPerWorker
                    - 1, finishCounter, results);
            workers[i].start();
        }

        /* wait until all workers finish */
        try {
            finishCounter.await(); 
        } catch (Exception ex) {
            ex.printStackTrace();
            System.exit(1);
        }

        /* print results */
        for (Integer i : results)           
            System.out.println(i);
    }

    public static void main(String[] args) {
        new ThreadsMain();
    }

}
package threads;

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;

public class Worker extends Thread {

    int start;
    int end;

    CountDownLatch finishCounter;
    ConcurrentLinkedQueue<Integer> results;

    Worker(int _start, int _end, CountDownLatch _finishCounter,
            ConcurrentLinkedQueue<Integer> _results) {
        start = _start;
        end = _end;
        finishCounter = _finishCounter;
        results = _results;
    }

    @Override
    public void run() {
        for (int i = start; i <= end; i++) {
            /* do something */
        }
        results.add(end); /* fake result */
        finishCounter.countDown(); /* release main thread */
    }
}

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0