Threads Nebenläufige Programmierung

[valentina2013]

Hi,
habe hier ein kleines Programm :

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread2 extends Thread {
private int num;
private static int global=0;
private static String name;
private static Lock lock=new ReentrantLock();

public MyThread2(int num,String name){
    this.num=num;
    this.name=name;
}
@Override
public void run(){
    while(global<1000){
        try{
            lock.lock();
            global+=num;
            Thread.sleep(10);
            System.out.println(global+" "+name);
            lock.unlock();
           
            Thread.sleep((int) (Math.random()*1000));
        }
        catch(InterruptedException e){
            System.out.println("Ops!");
        }
    }
}

public static void main(String[] args) {
        for(int i=0;i<3;i++)
            new MyThread2((int) Math.pow(10, i), "Thread"+i).start();

    }

}

gefragt ist ob die Ausgabe des Programms eindeutig ist. Und man muss ein Auszug der ersten 10 Kommandozeilen-Ausgaben angeben.

Lasse ich es in Eclipse laufen kommten immer diese Zeilen:
1 Thread2
11 Thread2
111 Thread2
211 Thread2
alle anderen sind abwechselnd.
Meine Frage: ich hätte erwartet dass eigentlich Thread 0 ausgegeben wir da die threads mit einer Schleife erzeugt werden und dort der o-te das erste ist. warum ist das so?und vielleicht könnt ihr auch sagen ob die ausgabe eindeutig ist (also ohne eclipse/JVM die ausgabe erkennbar).
Danke schön ;-)

 

[Dompteur]

Du speicherst den Namen in einer statischen Variablen:

private static String name;

 

[valentina2013]

super danke , habe korrigiert. Noch eine Frage: kann hier Deadlock auftreten? ich meine Nein, denn es gib nur einen Lock und der wird auch freigegeben sobald

(global<1000)

. Stimmt das?

 

[nvidia]

[...] kann hier Deadlock auftreten? [...]

Ja.

 

[valentina2013]

warum?

 

[Tarrew]

Wenn beim:

Thread.sleep(10);

eine Exception auftritt gibst du den Lock nicht frei.
In den Javadocs gibt es auch ein Beispiel wie man das eig. macht:

 class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
}

 

[nvidia]

Der Vollständigkeit halber möchte ich noch darauf hinweisen das der Code noch eine "race condition" enthält die zu unschönen Effekten führen kann. Und dass das Fangen der InterruptedException ohne den interrupt-Status am Thread neu zu setzen kein guter Stil ist.