Producer/Consumer Thread mit notify auf File

[lokly]

Hi,

ich habe 2 Threads - einen Producer und einen Consumer Thread.
Der Producer erstellt eine File. Der Consumer benötigt die File um bei sich weiter zu machen - mal etwas vereinfacht dargestellt ohne try catch usw:

class Producer extends Thread {
	private File f; 
	Producer(File f){
		this.f=f;
	}
	
	public void run(){
		synchronized(v){
			//Fülle f mit Daten
			f.notify();
		}
	}
}

class Consumer extends Thread {
	private File f; 
	Consumer(File f){
		this.f=f;
	}
	
	public void run(){
		synchronized(v){
			if(f.wird noch genutzt){
				f.wait();
			}
			//Mache was mit f
		}
	}
}

class Ausfuehren{
	public static void main(String [] arg){
		File f = new File("xyz");
		Producer p = new Producer(f);
		Consumer c = new Consumer(f);
		p.start();
		c.start();
	}
}

Das Problem was ich habe: if(f.wird noch genutzt) - wie kann ich feststellen, dass f noch von dem anderen Thread genutzt wird?
Hab das Bespiel mit einem Vector anstatt einer File gesehen. Dort wurde es so gelöst:

if (vector.size() < 1) {
	vector.wait();
}

Weiß einer von euch, wie ich das ganz mit einer File machen kann?

Vielen Dank und besten Gruß.

 

[SlaterB]

definiere nebem f noch einen boolean
fInUse = true;

der Producer setzt die Variable auf false wenn er fertig ist, der Consumer fragt sie ab

 

[lokly]

Aber auf nen primitive Datentypen kann man doch kein notify/wait aufrufen..

Soweit wie ich das ganze Schema sehe:
wait setzt ein Sperrflag, notify gehebt das Sperrflag auf.
Producer erstellt eine File und notifyt.
Consumer nimmt nur auf die File zugriff, wenn es verfügbar ist - ansonsten setzt er das File in Consumer auf wait. Wenn der Consumer genotift wird, startet er.
Allerdings muss ich ja jetzt wissen, ob das File vom Producer noch erstellt wird - aber ich weiß nicht wie..
Was ich schon versucht hab: Über File.length die Größe in einer while schleife abgefragt - aber so wirklich super läuft das ganz nicht - ist ja auch nicht wirklich professionell..
Gibts nicht noch ne andere Möglichkeit um das gut nebenläufig hinzubekommen?

 

[SlaterB]

am wait/ notify auf der Datei ändert sich nix, vielleicht reicht das ja auch schon,
erfolgt das notity nicht genau dann wenn der Producer fertig ist?

aber egal, selbst wenn man sich darauf nicht verlassen kann hat man immer noch eine exakt passende Situation:
> Wenn der Consumer genotift wird, startet er. Allerdings muss ich ja jetzt wissen, ob das File vom Producer noch erstellt wird

genau diese Information, ob der Producer fertig ist oder nicht, gibt der boolean an, true oder false

 

[lokly]

Habs mir jetzt mal einfacher gemacht und das File in eine Vectorliste gepackt. Producer erzeugt und legt in die Liste, Consumer entfernt aus der Liste - dabei kann man das vector.size<1 benutzen, was oben schon angegeben ist.
Ich danke aber vielmals für die Hilfe und die Denkanstöße..

 

[Michael...]

[JAVA=7]
public void run(){
synchronized(v){[/code]

Du solltest synchronized an dem File-Objekt aufrufen. Bsp.:

import java.io.*;

public class ProducerConsumerDemo {
	public static void main(String[] args) {
		File file  = new File("C:\\test\\hurz.txt");
		new Thread(new Producer(file)).start();
		new Thread(new Consumer(file)).start();
	}
}

class Producer implements Runnable {
	private File file;

	public Producer(File file) {
		this.file = file;
	}

	public void run() {
		synchronized (file) {
			System.out.println("producer will write to file: " + file.getName());
			try {
				PrintWriter writer = new PrintWriter(new FileWriter(file));
				for (int i = 0; i < 10; i++) {
					writer.println("Test " + i);
					writer.flush();
					try {
						Thread.sleep(500);
					} catch (InterruptedException exc) {exc.printStackTrace();}
				}
				writer.close();
			} catch (IOException exc) {exc.printStackTrace();}
		}
	}
}

class Consumer implements Runnable {
	private File file;

	public Consumer(File file) {
		this.file = file;
	}
	
	public void run() {
		synchronized(file) {
			System.out.println("consumer can now read file: " + file.getName());
		}
	}
}