diff --git a/src/main/java/_10/_2/QuickSortThreaded.java b/src/main/java/_10/_2/QuickSortThreaded.java
new file mode 100644
index 0000000..8e06a92
--- /dev/null
+++ b/src/main/java/_10/_2/QuickSortThreaded.java
@@ -0,0 +1,53 @@
+package _10._2;
+
+import provided._10._2.*;
+
+public class QuickSortThreaded extends QuickSort implements Runnable {
+	private int[] numbers;
+	private int leftIndex;
+	private int rightIndex;
+
+	public QuickSortThreaded() {
+	}
+
+	public QuickSortThreaded(int[] numbers, int leftIndex, int rightIndex) {
+		this.numbers = numbers;
+		this.leftIndex = leftIndex;
+		this.rightIndex = rightIndex;
+	}
+
+	@Override
+	public void run() {
+		quickSort(numbers, leftIndex, rightIndex);
+	}
+
+
+	/**
+	 * sortiert das uebergebene Array in aufsteigender Reihenfolge
+	 * gemaess dem QuickSort-Algorithmus (parallel!)
+	 */
+	public static void sort(int[] numbers) {
+		new QuickSortThreaded().quickSort(numbers, 0, numbers.length - 1);
+	}
+
+	/**
+	 * der Quicksort-Algorithmus wird auf dem Array zwischen den
+	 * angegebenen Indizes ausgefuehrt
+	 */
+	protected void quickSort(int[] numbers, int leftIndex, int rightIndex) {
+		if (leftIndex < rightIndex) {
+			int pivotIndex = divide(numbers, leftIndex, rightIndex);
+			Thread threadLeft = new Thread(new QuickSortThreaded(numbers, leftIndex, pivotIndex - 1));
+			Thread threadRight = new Thread(new QuickSortThreaded(numbers, pivotIndex + 1, rightIndex));
+			threadLeft.start();
+			threadRight.start();
+			try {
+				threadLeft.join(); // Wait for first thread.
+				threadRight.join();
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+}
diff --git a/src/main/java/provided/_10/_2/QuickSort.java b/src/main/java/provided/_10/_2/QuickSort.java
new file mode 100644
index 0000000..1f87669
--- /dev/null
+++ b/src/main/java/provided/_10/_2/QuickSort.java
@@ -0,0 +1,80 @@
+package provided._10._2;
+
+public class QuickSort {
+
+	/**
+	 * sortiert das uebergebene Array in aufsteigender Reihenfolge
+	 * gemaess dem QuickSort-Algorithmus
+	 */
+	public static void sort(int[] numbers) {
+		new QuickSort().quickSort(numbers, 0, numbers.length - 1);
+	}
+
+	/**
+	 * der Quicksort-Algorithmus wird auf dem Array zwischen den
+	 * angegebenen Indizes ausgefuehrt
+	 */
+	protected void quickSort(int[] numbers, int leftIndex, int rightIndex) {
+		if (leftIndex < rightIndex) {
+			int pivotIndex = divide(numbers, leftIndex, rightIndex);
+			quickSort(numbers, leftIndex, pivotIndex - 1);
+			quickSort(numbers, pivotIndex + 1, rightIndex);
+		}
+	}
+
+	/**
+	 * liefert den Index des Pivot-Elementes und ordnet das Array innerhalb
+	 * der angegebenen Indizes so um, dass alle Zahlen links vom Index
+	 * kleiner oder gleich und alle Zahlen rechts vom Index groesser
+	 * oder gleich dem Pivot-Element sind
+	 */
+	protected int divide(int[] numbers, int leftIndex, int rightIndex) {
+		int pivotIndex = choosePivotIndex(numbers, leftIndex, rightIndex);
+		int pivotValue = numbers[pivotIndex];
+		// das Pivot-Element kommt nach ganz rechts im Array
+		swap(numbers, pivotIndex, rightIndex);
+		int left = leftIndex - 1;
+		int right = rightIndex;
+		// ordne das Array so um, dass jeweils alle Elemente links vom
+		// Zeiger left kleiner und alle Elemente rechts vom Zeiger right
+		// groesser als das Pivot-Element sind
+		do {
+			left++;
+			while (left <= rightIndex && numbers[left] <= pivotValue)
+				left++;
+			right--;
+			while (right >= leftIndex && numbers[right] >= pivotValue)
+				right--;
+			if (left < right) {
+				swap(numbers, left, right);
+			}
+		} while (left < right);
+		// platziere das Pivot-Element an seine korrekte Position
+		if (left < rightIndex) {
+			swap(numbers, left, rightIndex);
+			return left;
+		} else {
+			return rightIndex;
+		}
+	}
+
+	/**
+	 * waehlt einen beliebigen Index zwischen den angegebenen Indizes
+	 */
+	protected int choosePivotIndex(int[] numbers, int leftIndex, int rightIndex) {
+		// in diesem Fall einfach der mittleren Index
+		return (leftIndex + rightIndex) / 2;
+	}
+
+	/**
+	 * tauscht die Elemente des Arrays an den angegebenen Indizes
+	 */
+	protected void swap(int[] numbers, int index1, int index2) {
+		if (index1 != index2) {
+			int tmp = numbers[index1];
+			numbers[index1] = numbers[index2];
+			numbers[index2] = tmp;
+		}
+	}
+	
+}
diff --git a/src/main/java/provided/_10/_2/QuickSortTest.java b/src/main/java/provided/_10/_2/QuickSortTest.java
new file mode 100644
index 0000000..a7e0817
--- /dev/null
+++ b/src/main/java/provided/_10/_2/QuickSortTest.java
@@ -0,0 +1,26 @@
+package provided._10._2;
+
+import _10._2.QuickSortThreaded;
+
+public class QuickSortTest {
+
+	public static void main(String[] args) {
+		int[] numbers = {2, 3, 9, 33, -2, 4, 55, 66, -234};
+		print(numbers);
+		QuickSort.sort(numbers);
+		print(numbers);
+		
+		int[] numbers2 = {2, 3, 9, 33, -2, 4, 55, 66, -234};
+		print(numbers2);
+		QuickSortThreaded.sort(numbers2);
+		print(numbers2);
+	}
+	
+	private static void print(int[] numbers) {
+		for (int number : numbers) {
+			System.out.print(number + " ");
+		}
+		System.out.println();
+	}
+
+}