uni/inf2440/hw3/Parallel.java

class Parallel implements Solver {
	class Worker implements Runnable {
		MultiRadix mr;
		int[] arr;
		int start, end;
		boolean done = false;
		Worker( int[] arr, int start, int end) {
			this.arr = new int[end - start];
			int j = 0;
			for (int i = start; i < end; ++i) {
				this.arr[j++] = arr[i];
			}
		}

		synchronized public void run() {
			arr = new MultiRadix().radixMulti(arr);
			done = true;
			notify();
		}

		synchronized public void waitFor() {
			while (!done) {
				try { wait(); } catch (InterruptedException ex) {}
			}
		}
	}

	public int[] sort(int[] arr) {
		int n = 2;
		int d = arr.length / n;

		Worker[] workers = new Worker[n];
		Thread[] threads = new Thread[n];

		for (int i = 0; i < n; ++i) {
			int start = d * i;
			int end;
			if (i == n - 1)
				end = arr.length;
			else
				end = d * (i + 1);

			Worker w; Thread t;
			workers[i] = w = new Worker(arr, start, end);
			threads[i] = t = new Thread(w);
			t.start();
		}

		for (int i = 0; i < n; ++i) {
			workers[i].waitFor();
			try {
				threads[i].join();
			} catch (InterruptedException ex) {}
		}

		int[] is = new int[n];
		for (int i = 0; i < n; ++i)
			is[i] = 0;

		for (int i = 0; i < arr.length; ++i) {
			int biggest = Integer.MAX_VALUE;
			int biggestJ = 0;
			Worker biggestW = null;

			for (int j = 0; j < n; ++j) {
				Worker w = workers[j];
				if (is[j] >= w.arr.length)
					continue;

				int num = w.arr[is[j]];

				if (num <= biggest) {
					biggest = num;
					biggestJ = j;
					biggestW = w;
				}
			}

			arr[i] = biggestW.arr[is[biggestJ]++];
		}

		return arr;
	}
}