Threads Producer-Consumer Problem

[blablub]

Guten Tag,

ich bin neu hier. Ich bin gerade dabei, ein simples Producer-Consumer Problem in Java umzusetzen.

Das Problem ist, dass das Programm endlos läuft, wenn der Consumer zuerst auf ein Element wartet. Anders herum, wenn ich zuerst ein Element einsetze (bzw. den Thread dafür starte) und danach den Consumer-Thread starte, dann geht alles.

Der Producer-Thread wird auch gar nicht mal aufgerufen (siehe System.out.println() in #41 bzw. setzt euch selber einen Breakpoint rein). Wieso?

Leider ist der Code etwas länger, deswegen entschuldige ich die Länge dieses Beitrages. Ich wusste nicht, ob man den Code bspw. auf Pastebin hochladen darf und hier nur auszugsweise zitieren darf.

Onlineversion des unteren Codes: Ideone.com - FoTSBW - Online Java Compiler & Debugging Tool (beachtet das "Time limit exceeded")
Onlineversion des laufbaren Codes (Vertauschung der zwei Zeilen, die die Threads starten): Ideone.com - fd9OKS - Online Java Compiler & Debugging Tool

Ich wäre euch für Hilfe sehr dankbar.

Grüße
blablub

import java.util.ArrayList;
import java.util.List;

public class Test {
	public static void main(String[] args) {
		new Test();
	}
	
	public Test() {
		DummyBuffer<String> buf = new DummyBuffer<String>(new ArrayList<String>(), 5);
		
		Thread prod = new Thread(new Producer(buf));
		Thread cons = new Thread(new Consumer(buf));
		
                // Wenn ich diese zwei Zeilen vertausche, funktioniert alles!
		cons.run();
		prod.run();
				
	}
	
	private class Consumer implements Runnable {
		private DummyBuffer<String> buf;
		
		public Consumer(DummyBuffer<String> buf) {
			this.buf = buf;
		}
		
		@Override
		public void run() {
			buf.take();
		}
	}
	private class Producer implements Runnable {
		private DummyBuffer<String> buf;
		
		public Producer(DummyBuffer<String> buf) {
			this.buf = buf;
		}
		
		@Override
		public void run() {
			System.out.println("Producer there...");
			buf.put("Hello World!");
		}
	}
	
	private class DummyBuffer<T> {
		private final int SIZE;
		private List<T> data;
		
		public DummyBuffer(List<T> sharedData, int maxSize) {
			SIZE = maxSize;
			data = sharedData;
		}
		
		public synchronized T take() {
			while (data.isEmpty()) {
				try {
					System.out.println("waiting... for taking");
					wait();
				}
				catch (InterruptedException e) {
					// Do nothing
				}
			}
			T item = data.remove(data.size() - 1);
			
			notifyAll();
			
			System.out.println("Removed item: " + item);
			return item;
		}
		
		public synchronized void put(T item) {
			while (data.size() >= SIZE) {
				try {
					wait();
				}
				catch (InterruptedException e) {
					// Do nothing
				}
			}
			data.add(item);
			
			System.out.println("notified");
			notifyAll();
			
			System.out.println("Put item: " + item);
		}
	}
}

 

[chalkbag]

Probiere mal mal mit cons.start() und prod.start(). Run ist blockierend.

Wunschausgabe ist ja wie folgt, also nur ein Durchgang?

Producer there...
waiting... for taking
notified
Put item: Hello World!
Removed item: Hello World!

 

[diggaa1984]

Thread.run startet den Thread nicht parallel sondern ruft einfach die Methode run auf (sequenziell) und dadurch hängst du ewig im Take, weil prod.run auch nie aufgerufen wird.

Threads immer mit start() starten.

 

[blablub]

Perfekt! Vielen Dank euch beiden!