Threads und synchrinisieren

[jappa]

Hallo,

ich arbeite mich gerade in Threads ein und bin jetzt beim Synchronisieren angelangt.
Dazu habe ich mir versuchsweise ein bisschen Code geschrieben:

import java.util.concurrent.locks.*;

public class synchron_1  {

	public static void main(String[] args) {
		Thread t1 = new Thread( new FooBar("Thread1") );
		Thread t2 = new Thread( new FooBar("Thread2" ) );
		t1.start();
		t2.start(); 
	}
}


class FooBar implements Runnable {
	
	private String threadName;
	private final ReentrantLock lock;
	
	public FooBar( String threadName ) {
		this.threadName = threadName;
		lock = new ReentrantLock();
		Thread t1 = new Thread( this );
		t1.setName(threadName);
	}
	
	public void run() {
		for( int i = 0; i < 5; i++ ) {
			foo();
		}
	}
	
	public void foo() {
		lock.lock();
			int i = 0;			
			while( i < 20 ) {
				System.out.println( threadName + ": i ist jetzt: " + i);
				i++;
			}			
		lock.unlock();
	}
	
	// oder eben so:
	/*
	public synchronized void foo() {
			int i = 0;			
			while( i < 20 ) {
				System.out.println( threadName + ": i ist jetzt: " + i);
				i++;
			}			
	}	
	
	*/
}

Aber egal ob ich die Methode foo() mit synchronized oder mit einem ReentrantLock sperre,
es kommen immer wieder bei der Konsolenaugabe Zeilen wie diese:


Thread2: i ist jetzt: 16
Thread1: i ist jetzt: 5
Thread1: i ist jetzt: 6
Thread1: i ist jetzt: 7
Thread2: i ist jetzt: 17
Thread2: i ist jetzt: 18
Thread2: i ist jetzt: 19

Dabei dachte ich, wenn ich die while-Schleife mit einem Lock sperre, kann genau das nicht mehr passieren und ein Thread zählt ununterbrochen von 0 bis 19.
Habe ich da was falsch verstanden oder falsch programmiert?

 

[Gast2]

private final ReentrantLock lock;

damit erzeugst Du für jedes Foobar-Object einen eigenen Lock

private static final ReentrantLock lock = new ReentrantLock();

wobei Dein Beispiel so in der Realität keine Probleme macht (alles schön auf dem eigenen Stack)

 

[nrg]

und was willst du mit:

		Thread t1 = new Thread( this );
		t1.setName(threadName);

bezwecken? versteh ich iwie net

 

[Michael...]

Thread t1 = new Thread( new FooBar("Thread1") );
Thread t2 = new Thread( new FooBar("Thread2" ) );

In Deinem Fall "besitzt" jeder Thread ein eigenes FooBar Objekt, dadurch kommen sie sich gar nicht in die Quere, da sie ja auf verschiedene Objekte zugreifen.

 

[Noctarius]

Prinzipiell ist der ReentrantLock aber dem normalen synchronized vorzuziehen meiner Meinung nach

PS:
[c]public synchronized void foo()[/c]
So ist der Synchronize auch nur pro Instanz.

 

[jappa]

OK, danke für die Antworten. Ich hab's verstanden.

@nrg: Ja, stimmt, was will ich eigentlich mit diesen beiden Zeilen. Danke für den Tip!