Threading - Unregelmäßige Lock-Vergabe

[Tarrew]

Hey, ich wiederhole grade ein bisschen was zum Thema Multithreading.

Habe mir als Test eine Klasse geschrieben mit einer consume und einer produce -Methode, die jeweils Integer aus einer ArrayList nehmen, bzw einfügen.

import java.util.ArrayList;
import java.util.Random;

public class Factory {

	ArrayList<Integer> list = new ArrayList<Integer>();
	Random r = new Random();

	public synchronized void produce() throws InterruptedException {
		while (list.size() == 10) {
			wait();
		}
		int number = r.nextInt(200);
		list.add(number);
		System.out.println("Added int: " + number + "\t Queue-size: "
				+ list.size());
		notify();
		
	}

	public synchronized void consume() throws InterruptedException {
		while (list.size() == 0) {
			wait();
		}
		int number = list.remove(0);
		System.out.println("Acquired int: " + number + "\t Queue-size: "
				+ list.size());

		notify();

	}

	public static void main(String[] args) {
		Factory p = new Factory();
		Thread producer = new Thread(new Runnable() {

			@Override
			public void run() {
				while (true) {
					try {
						p.produce();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}

				}
			}
		});

		Thread consumer = new Thread(new Runnable() {

			@Override
			public void run() {
				while (true) {
					try {
						p.consume();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		});

		producer.start();
		consumer.start();
	}

}

Das ganze läuft zu Testzwecken in einer Endlosschleife.

Jetzt hätte ich mit folgendem Szenario gerechnet:
Einer der beiden Threads holt sich den Lock auf das Factory-Objekt. Falls es der Consumer-Thread ist, legt der sich schlafen, weil die Liste leer ist, falls es der Producer ist, fügt er ein Objekt ein und weckt den Consumer auf.

Dann sollten beide Threads versuchen den Lock zu bekommen.

Allerdings kriegt der Producer jedes mal den Lock, bis die Liste voll ist(in meinem Beispiel auf 10 begrenzt), und sich dann schlafen legt.
Danach darf der Consumer ran und kann sich ein Objekt rausnehmen, und ruft wieder notify.
Auch hier hätte ich damit gerechnet, dass wieder beide Threads versuchen den Lock zu kriegen(was ja wahrscheinlich auch passiert).

Aber auch hier kriegt der Consumer-Thread jedes Mal den Lock bis die Liste leer ist und er ist sich wieder schlafen legt.

Hatte es schon mit ein paar Sleeps probiert, weil ich dachte, das der Thread vllt etwas braucht um "aufzuwachen" und dann den Lock nicht mehr kriegen kann, aber das änderte nichts.
Aber das wäre ja eig. auch keine Erklärung. Wenn in der Liste 5Elemente sind, schläft keiner der beiden Threads und trotzdem kriegt einer der Threads jedes mal den Lock, bis die Liste voll bzw leer ist.

Wie kommt es, dass die Lock-Vergabe so ist? Dh erstmal 10x produce, dann 10x consume, dann 10x produce und so weiter. Es kommt im Prinzip nie zu einer 50/50 Vergabe, womit ich eigentlich gerechnet hätte.

Hoffe mich kann da jemand aufklären

Grüße