Thread Synchronisation

[Anton87]

Hallo! Sitze seit Stunden an meinem Code und kriege es nicht hin :-(
Meine Klasse RWMonitor soll zulassen, dass verschiedene Threads auf dasselbe Objekt gleichzeitig Lesesperren ( mode='r' halten können. Aber es ist verboten das gleichzeig zu der Lesesperre die Schreibsperre mod ='w' gehalten wird. Die Threads müssen sozusagen zerstückelt das Programm ablaufen...
Der Fehler liegt denke ich in der lock() bzw unlock() Methode. Aber bloss wo....??
Die Trw Klasse erzeugt ein RWMonitor und 4 Threads. In der run() Mehtode soll mit zeitlicher Verzögerung jeweils die Schreibsperre bzw. Lesesperre gesetzt und freigegeben werden..
Was mache ich falsch?
Hat jemand einen Tipp? :roll:

public class RWMonitor extends Thread implements Runnable {
	
	static char mode;
	static Integer anzahlLeseSperre = 0;
	static boolean schreibSperre = false;

	

	public static synchronized void lock(Thread t, char mode){
		
		//Setzen der Lesesperre
		if ( mode=='r')
		{
		if(schreibSperre == false)  {anzahlLeseSperre++;}}
				
			else{
					
				while(schreibSperre != false ){
						
					try{Thread.sleep(10);}
					catch( InterruptedException e)
					{System.out.println("Ein Fehler ist aufgetreten" + e);}	
						}
						anzahlLeseSperre++;}
						
		//Setzen der Schreibsperre	
		if( mode =='w')
			
			if(schreibSperre == false && anzahlLeseSperre == 0) {schreibSperre = true;}
		
				else{
				
				while(schreibSperre!= false && anzahlLeseSperre > 0){
						
					try{Thread.sleep(10); }
					catch( InterruptedException e)
					{System.out.println("Es ist ein Fehler aufgetreten" + e);}
					}
					schreibSperre = true;}
		}

	
	public static synchronized void unlock(Thread t, char mode){
		//Entsperren der Lesesperre
		if ( mode=='r')
			
			if(anzahlLeseSperre!=0)
				
				{anzahlLeseSperre--; schreibSperre = false;}
		//Entsperren der Schreibsperre	

		if( mode =='w')
			
			if(schreibSperre == true) schreibSperre = false;
		}	
}

import java.lang.Math;

public class Trw extends Thread {
	
	//RWMonitor mon;
	
	public static void main (String [] arg){
		
	//RWMonitor mon = new RWMonitor();	
	
	Trw t1 = new Trw();
	Trw t2 = new Trw();
	Trw t3 = new Trw();
	Trw t4 = new Trw();
	
	t1.start();
	t2.start();
	t3.start();
	t4.start();
	
	}
	
	public void run(){
		
		//int counter=0;
		char [] mode  = {'r','w'};
		
		for (int z = 0;z<5;z++){

		// Punkt 1.
			try{Thread.sleep((long)(Math.random()*50+1));}
				catch(InterruptedException e){
					System.out.println("Ein Fehler"+ e);}
		// Punkt 2.
		RWMonitor.mode = mode [(int)(Math.random()*2)];
		
		System.out.println(currentThread().getName()+ 
				" steht vor Eintritt  " + "Mode = "+ RWMonitor.mode+" "+RWMonitor.anzahlLeseSperre+RWMonitor.schreibSperre);
		
		RWMonitor.lock(currentThread(), RWMonitor.mode);
		
		System.out.println(currentThread().getName()+ 
				" hat betreten        " + "Mode = "+ RWMonitor.mode+" "+ RWMonitor.anzahlLeseSperre+RWMonitor.schreibSperre);
		
		    try{Thread.sleep((long)(Math.random()*50+1));}
			catch(InterruptedException e){
				System.out.println("Ein Fehler"+ e);}
		
		RWMonitor.unlock(currentThread(), RWMonitor.mode);
		
		System.out.println(currentThread().getName()+ 
				
				" steht vor Verlassen " + "Mode = "+ RWMonitor.mode+" "+RWMonitor.anzahlLeseSperre+RWMonitor.schreibSperre);

		
	}
	}	
	}

 

[SlaterB]

da lag ja einiges im Argen, als aller erstes: Thread.sleep() gibt NICHT den synchronized-Block frei!

außerdem ist es schlecht, wenn sich nicht jeder Thread seinen mode merkt
du gehts da mit dem Parameter mode einen richtigen Weg,
aber wenn als Parameter nur genau der statische Wert der Klasse übergeben wird, dann ist das erstens nutzlos (RWMonitor könnte genausogut selber die statische Variable anschauen),
viel schlimmer aber es ist falsch:
Thread 1 setzt den Mode auf r, geht rein, Thread 2 setzt den Mode auf w, geht rein,
nun will Thread 1 wieder raus, Mode ist w, wie soll Thread 1 wissen, dass er selber r ist?

--------

in lock noch zwei Fehler:
wenn der mode 'w' ist, dann wird das else des ersten ifs betreten, an deren Ende
> anzahlLeseSperre++;
steht

------

im richtigen w-Abschnitt steht
> while(schreibSperre!= false && anzahlLeseSperre > 0){

es wird also nur gewartet, wenn schreibsperre gesetzt ist UND auch noch Lesesperren da sind,
es muss aber auch dann gewartet werden, wenn nur eine dieser Bedingungen erfüllt ist

------

> import java.lang.Math;

aus java.lang muss man nixx importieren

-----
hier eine funktionierende Variante:

public class Trw extends Thread {

	static RWMonitor mon = new RWMonitor();

	public static void main(String[] arg) {

		// RWMonitor mon = new RWMonitor();

		Trw t1 = new Trw();
		Trw t2 = new Trw();
		Trw t3 = new Trw();
		Trw t4 = new Trw();

		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}

	public void run() {

		// int counter=0;
		char[] mode = { 'r', 'w' };

		for (int z = 0; z < 5; z++) {

			// Punkt 1.
			try {
				Thread.sleep((long) (Math.random() * 50 + 1));
			} catch (InterruptedException e) {
				System.out.println("Ein Fehler" + e);
			}
			// Punkt 2.
			char m = mode[(int) (Math.random() * 2)];

			System.out.println(currentThread().getName() + " steht vor Eintritt   " + "Mode = " + m
					+ " " + mon.anzahlLeseSperre + mon.schreibSperre);

			mon.lock(m);

			System.out.println(currentThread().getName() + " hat betreten         " + "Mode = " + m
					+ " " + mon.anzahlLeseSperre + mon.schreibSperre);

			try {
				Thread.sleep((long) (Math.random() * 50 + 1));
			} catch (InterruptedException e) {
				System.out.println("Ein Fehler" + e);
			}

			System.out.println(currentThread().getName() + " steht vor  Verlassen " + "Mode = " + m
					+ " " + mon.anzahlLeseSperre + mon.schreibSperre);

			mon.unlock(m);

			System.out.println(currentThread().getName() + " steht nach Verlassen " + "Mode = " + m
					+ " " + mon.anzahlLeseSperre + mon.schreibSperre);

		}
	}
}

class RWMonitor {

	int anzahlLeseSperre = 0;
	boolean schreibSperre = false;

	public synchronized void lock(char mode) {
		// Setzen der Lesesperre
		if (mode == 'r') {
			while (schreibSperre) {
				try {
					wait();
				} catch (InterruptedException e) {
					System.out.println("Ein Fehler ist aufgetreten" + e);
				}
			}
			anzahlLeseSperre++;
		}

		// Setzen der Schreibsperre
		if (mode == 'w') {
			while (schreibSperre || anzahlLeseSperre > 0) {
				try {
					wait();
				} catch (InterruptedException e) {
					System.out.println("Es ist ein Fehler aufgetreten" + e);
				}
			}
			schreibSperre = true;
		}
	}

	public synchronized void unlock(char mode) {
		// Entsperren der Lesesperre
		if (mode == 'r') {
			anzahlLeseSperre--;
		}
		// Entsperren der Schreibsperre
		if (mode == 'w') {
			schreibSperre = false;
		}
		notify();
	}
}

 

[Anton87]

Vielen Dank!
Aber ich habe vergessen zu schreiben, dass unser Lehrer will, dass wir ohne die Funktionen notify, wait auskommen. Also nur mit synchronized und sleep(). Sonst wäre es ja zu einfach, sagt er.......

 

[Anton87]

wait() kann ich ja vielleicht durch sleep() ersetzen... Aber wie ersetze ich notify()??

 

[SlaterB]

wait kannst du eben nicht durch sleep ersetzen, da dadurch das synchronized nicht aufgehoben wird,
(solange kann niemand unlocken)

die Alternative wäre nun, dennoch wieder sleep zu benutzen, aber dafür den synchronized-Bereich zu verlassen,
entweder die ganze Operation lock(),
ein Rückgabewert true/ false gibt an, ob es geklappt hat oder ob gewartet werden muss + neuer Versuch,
oder innerhalb von lock mehrere synchronized(this) {}-Abschnitte und dazwischen mit sleep warten,

da jedes sleep selbstständig wieder aufhört ist dann auch kein notify() nötig

 

[André Uhres]

unser Lehrer will, dass wir ohne die Funktionen notify, wait auskommen. Also nur mit synchronized und sleep(). Sonst wäre es ja zu einfach, sagt er.......

Er will euch beibringen, wie man falsch synchronisieren muss :lol:

 

[Anton87]

Hmm... Das hat der Lehrer uns natürlich nicht erzählt. Typisch...
Muss ich den ganzen Block für mode=r ein kappseln bzw. mode=w und zwischen den beiden GROßen warten mit sleep() oder einzelne teile innerhalb von großen IF-Abfragen einkapseln?

 

[SlaterB]

was du einkapseln musst ergit sich allein aus der Logik,
das Prüfen der Stati und deren Veränderung,

bisschen selber denken oder wenn nicht dann zumindest ausprobieren musst du schon,

unlock könnte übrigens völlig ohne synchronized auskommen

 

[Anton87]

Habe ich ja versucht... Ich weiss nicht genau, wo ich synchronized(Klasse.class) packen soll... Soll ich jede einzelne Abfrage abkapseln oder nur die GANZE Methode...??
Bei mir sieht dann so aus:

class RWMonitor1 { 

   int anzahlLeseSperre = 0; 
   boolean schreibSperre = false; 
   boolean upgradeSperre = false;


   public void lock(Thread t, char mode) { 
	   synchronized (RWMonitor1.class) {
		
	
      // Setzen der Lesesperre 
      if (mode == 'r') { 
         while (schreibSperre) { 
        	 try { 
                // wait(); 
        		Thread.sleep(10); 
        		   		 
              } catch (InterruptedException e) { 
                 System.out.println("Ein Fehler ist aufgetreten" + e); 
              } 
           } 
           anzahlLeseSperre++; 
        } 
	   }// Die Klammer von Synchronized
	   
	   synchronized (RWMonitor1.class) {

      // Setzen der Schreibsperre 
      if (mode == 'w') { 
         while (schreibSperre || anzahlLeseSperre > 0 || upgradeSperre) { 
            try { 
           //  wait(); 
              
             Thread.sleep(10); 
              
            } catch (InterruptedException e) { 
               System.out.println("Ein Fehler" + e); 
            } 
         } 
         schreibSperre = true; 
      } 
	}// Klammer von Synchronized
      synchronized (RWMonitor1.class) {
		
      // Setzen der UpgradeSperre
      if(mode=='u'){
    	  while(schreibSperre || upgradeSperre ){
    		  try {
    			//  wait();
    			  Thread.sleep(10);
    		  }catch (InterruptedException e) {
				System.out.println("Fehler"+e);
			  } 
    	  }   	  	  
    	  upgradeSperre = true;
      }
	 }
    } // ist die Klammer von Synchron

   public synchronized  void unlock(Thread t, char mode) { 
      // Entsperren der Lesesperre 
      if (mode == 'r') { 
         anzahlLeseSperre--; 
      } 
      // Entsperren der Schreibsperre 
      if (mode == 'w') { 
         schreibSperre = false; 
      } 
      // Entsperren der UpgradeSperre
      if( mode == 'u'){
    	  upgradeSperre = false;
      }
     // notify(); 
   } 
   
   // Für Aufgabe 4.2
   /*public synchronized void unlock(Thread t) {
	   
	      // Entsperren der Lesesperre 
	      if (anzahlLeseSperre!=0) { 
	         anzahlLeseSperre--; 
	      } 
	      // Entsperren der Schreibsperre 
	      if (schreibSperre == true) { 
	         schreibSperre = false; 
	      } 
	      notify(); 

}*/
}

 

[Anton87]

Und die geänderte TRW1 Klasse:

public class Trw1 extends Thread { 

   static RWMonitor1 mon = new RWMonitor1(); 

   public static void main(String[] arg) { 

	  
      Trw1 t1 = new Trw1(); 
      Trw1 t2 = new Trw1(); 
      Trw1 t3 = new Trw1(); 
      Trw1 t4 = new Trw1(); 

      t1.start(); 
      t2.start(); 
      t3.start(); 
      t4.start(); 

   } 

   public void run() { 

	  //char[] mode = { 'r', 'w'}; Nur für Punkt 4.1
      char[] mode = { 'r', 'w','u' }; 

      for (int z = 0; z < 5; z++) { 

         // Punkt 1. 
         try { 
            Thread.sleep((long) (Math.random() * 50 + 1)); 
         } catch (InterruptedException e) { 
            System.out.println("Ein Fehler" + e); 
         } 
         // Punkt 2. 3 
         //char m = mode[(int) (Math.random() * 2)]; 50% Wahrscheinlichkeit
         char m = mode[(int) (Math.random() * 3)]; // 1/3 Wahrscheinlichkeit
         
         System.out.println(currentThread().getName() + " steht vor Eintritt   " + "Mode = " + m 
               + " " + mon.anzahlLeseSperre + mon.schreibSperre); 

         mon.lock(currentThread(),m); 
         //mon.unlock(currentThread(), RWMonitor1.mode);
         
         //Punkt 4
         System.out.println(currentThread().getName() + " hat betreten         " + "Mode = " + m 
               + " " + mon.anzahlLeseSperre + mon.schreibSperre); 
         //Punkt 5
         try { 
            Thread.sleep((long) (Math.random() * 500 + 1)); 
         } catch (InterruptedException e) { 
            System.out.println("Ein Fehler" + e); 
         } 
         //Punkt 6
         System.out.println(currentThread().getName() + " steht vor  Verlassen " + "Mode = " + m 
               + " " + mon.anzahlLeseSperre + mon.schreibSperre); 
         //Punkt 7
         
         mon.unlock(currentThread(),m); 
         // mon.unlock(currentThread()); für Aufgabe 4.2
         
         System.out.println(currentThread().getName() + " steht nach Verlassen " + "Mode = " + m 
               + " " + mon.anzahlLeseSperre + mon.schreibSperre); 

      } 
   } 
}

 

[Anton87]

DANKE SCHÖN SlaterB!
Bin nun endlich selbst drauf gekommen...War eine schwere Geburt! VIELEN VIELEN DANK!!!!