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

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

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

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 */
	}
}