Threads blocken

[rand0m]

Hi.

Leider eine extreme Anfängerfrage zu der ich einfach keine Lösung find:
Wie starte ich 2 Threads ohne dass mein ganzes Programm wegen dem 1. "hängt".

Bsp.:

1
2
new ClientThread(serverSocket.accept(), this).start();  
new ClientDataThread(5999).start();

die 2 new Threads hab ich als eigene Klassen geschrieben.
Aber da ein Thread den anderen Blockt komm ich gar nicht erst zum 2.

ich

lg

[tim staeglich]

Hi,

an Deiner Frage sind auch schon Nichtanfänger verzweifelt also ist schon ok.

Guck Dir mal Semaphore an: http://java.sun.com/j2se/1.5.0/docs/...Semaphore.html

Man kann auch ohne Semaphore ein Thread Scheduling machen, aber so ist es am unkompliziertesten. Der Semaphore sorgt dafür, dass jeder Thread zu seinem Recht kommt.
So wird das Verhungern von Threads verhindert.

Bei eigenen Implementationen, die "synchronized" benutzen können, besteht das Risiko von Deadlocks, es ist aber eine Alternative. Mit synchronized Methoden oder Attributen bekommt jeder Thread einen eigenen Monitor. Benutzt man normalerweise um zu verhindern, dass zwei oder mehr Threads auf dieselbe Ressource gleichzeitig zugreifen.

Für ein einfaches Scheduling wie Du es brauchst, ist Semaphore schnell und unkompliziert.

Du könntest eine Warteschlange auch selbst bauen, packst die Threads in eine Liste
und gibst jedem Thread ein Zeitintervall um zu agieren, schläferst ihn dann ein und n immst den nächsten dran. Hier könntest Du selbst (als Lerneffekt) Betriebssystem Algorithmen ausprobieren (Last In – First Out out etc...).

Wenn ich Zeit finde, poste ich nochmal Beispielcode (am WE evtl.).

Grüßr, Tim

[tim staeglich]

So, in deiner Main Klasse muss es einen Semaphore geben, den jeder Thread
übergeben bekommen muss:

1
private static final Semaphore semaphore = new Semaphore(5, true);

5 bedeutet, der Semaphore lässt 5 Threads gleichzeitig rein.
der Parameter true ist der Fairness Parameter. Er garantiert, dass jeder Thread
zu seinem Recht kommt.

Innerhalb deiner Thread Klasse (z.B. MyJob) hast Du ja eine Methode,
die er bei Aufruf von "run()" ausführen soll.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void work() throws InterruptedException{         
    //aquire & release would enable this thread to run eternally,
    //or until this method was finished
        
            getSemaphore().acquire();
            
                        int n=0;
            while(n < 1000){//do job eternally              
                System.out.println( getName() );                
            }
 
            getSemaphore().release();
        
    }

getSemaphore() sollte natürlich den Semaphore liefern.

So hast Du alle Threads (im Beispiel 5) gleichmäßig am Laufen.

Grüße, Tim

[rand0m]

ah okey danke!
Werd ich gleich mal ausprobieren

[Cojote]

Ein Thread ist von sich aus nebenläufig, das heißt du brauchst keine Semaphore um zwei Threads gleichzeitig laufen zu lassen.
Ein Semaphor ist ein Instrument zur Synchronisation mehrerer Threads, bewirkt also genau das Gegenteil.

Ich würde eher darauf tippen, dass was in den beiden Thread-Klassen falsch verstanden wurde. Kannst du mal Beispielcode posten?

[Cojote]

Hab mir deinen Code nochmal angesehen

new ClientThread(serverSocket.accept(), this).start();
new ClientDataThread(5999).start();

Das Problem ist dass du dem Client-Thread schon serverSocket.accept() übergeben willst. die accept Methode blockiert aber. Noch bevor der Thread überhaupt erstellt wird blockiert das ganze. Das Problem ist also nicht der Thread an sich sondern dein Hauptprogramm.

Die Lösung wäre serverSocket zu übergeben und das accept in der run-Methode des Threads auszuführen.

[tim staeglich]

Threads sind von sich aus nebenläufig, das stimmt.

Aber: das Scheduling wird in Java 5 von der JVM, in Java 1.4 vom Betriebssystem durchgeführt.

D.h. die Threads sind NICHT garantiert nebenläufig/gleichberechtigt.
Threads könne verhungern.

Wenn Deine JVM oder Betriebssystem meint, ein Thread braucht mehr Ressourcen als der andere und dann bekommt er die auch.

Lässt Du 2 Threads unendlich hochzählen (probiers mal aus), kommt Nr. 2 nie mehr an die Reihe.

Daher brauchst Du auf jeden Fall Semaphore für ein Scheduling (oder die von mir geschilderten synchronized Geschichten), alleine um ConcurrentModificationExceptions zu vermeiden. und auch, damit alle Threads gleichberechtigt und nicht willkürlich dran kommen.

Als Entwickler wünscht man sich oft eine Kontrolle über diese Dinge, anstatt
die JVM oder das Betriebssystem Sachen machen zu lassen, die man nicht möchte...

Die Aquire und Release methoden sind da, um den Thread einen Block ausführen zu lassen, wenn er drankommt, und zwar bis zum Ende. Diese methoden verhindern sehr wohl, wie Cojote andeutet, dass ein anderer Thread dazwischenfunkt.

Grüße, Tim

[rand0m]

Hab mir deinen Code nochmal angesehen

new ClientThread(serverSocket.accept(), this).start();
new ClientDataThread(5999).start();

Das Problem ist dass du dem Client-Thread schon serverSocket.accept() übergeben willst. die accept Methode blockiert aber. Noch bevor der Thread überhaupt erstellt wird blockiert das ganze. Das Problem ist also nicht der Thread an sich sondern dein Hauptprogramm.

Die Lösung wäre serverSocket zu übergeben und das accept in der run-Methode des Threads auszuführen.

Sorry tim ich hab zu wenig zu dem Problem gesagt, ich glaub dass was ich eigentlich suche ist Cojotes Lösung.
-Ich hatte im ClientThread aber alles mögliche stehen, dass jetzt dank dem accept, dass jetzt im Thread bei der run Methode steht, nicht lauft bzw. drannkommt?.
Sprich der Server baut sich auf aber wenn ich mit dem Client connecte passiert nichts..auch keine Exceptions bzw. konnte ich vorher beim Client schreiben und jetzt hängt er total.

+beide Threads scheinen jetzt zu laufen da ich von beiden eine Meldung bekomme

lg

[Cojote]

Ich habe nicht so ganz verstanden ob sich das Problem erledigt hat oder ob nochwas hängt. Falls ja kannst du mal ein wenig Code posten?

[rand0m]

Wow okey sorry, ich hab einen sehr dummen Fehler beim öffnen / createn des Serversockets gemacht.
Also die accept() in die run() Methode zu packen war die Lösung.
Nur schaff ichs jetzt nicht mehr dass mehrere Client auf den Server zugreifen können.
Ein Client kann und dann kein weiterer.
Ich muss .accept() in eine Schleife packen denk ich mal nur will das auch nicht funktionieren.
->

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  public ClientThread(ServerSocket serverSocket,Server server) throws IOException {
    super("ClientThread");
    this.serverSocket = serverSocket;
    this.server = server;
    }
 
        public void run() {
  
        try{
            
                Socket socket = serverSocket.accept();
                                
        this.out = new PrintWriter(socket.getOutputStream(), true);
        BufferedReader in = new BufferedReader(
                new InputStreamReader(
                socket.getInputStream()));

[Cojote]

Hi,

wie du schon erkannt hast müsstest du das ganze noch in ne Schleife packen. Sonst akzeptiert er die erste Verbindung und läuft dann durch, danach ist der Server Thread weg.
Du könntest z.B. ne Endlosschleife reinbringen (oder besser du überlegst dir n Abbruchkriterium, das eintritt wenns irgendwelche Probleme gibt die die Weiterausführung unmöglich machen)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
while(true) {
try{
            
                Socket socket = serverSocket.accept();
                                
        this.out = new PrintWriter(socket.getOutputStream(), true);
        BufferedReader in = new BufferedReader(
                new InputStreamReader(
                socket.getInputStream()));
        ....
        socket.close();
}
...
}

Was du programmierst ist ein sequentieller Server, das heißt er kann nur auf eine einzige Anfrage zur gleichen Zeit reagieren. Arbeitet dein Server gerade eine Anfrage ab, so ignoriert er ganz einfach alle weiteren Anfragen, bis er wieder zu socket.accept() kommt (achja immer schön den Socket schließen wenn Kommunikation beendet).
Jetzt weiß ich natürlich nicht was genau du programmieren willst. Ist das ganze nur lokal mit Client und Server könntest du Client und Server so synchronisieren, dass keiner der Clients eine neue Anfrage stellen kann solange der Server noch an einer Anfrage arbeitet.

Ein anderer Ansatz wäre ein Multithreaded Server. Beim Multithreaded Server erzeugt der Server Thread bei Start eine beliebige Anzahl von weiteren Threads (so genannten Worker-Threads).
Aufgabe des Servers ist nur socket.accept auszuführen und das Socket Objekt in ne Datenstruktur zu werfen. Ein Worker-Thread entnimmt das Socket Objekt und arbeitet die Anfrage ab. So kann der Server beliebig viele (ich meine eine größere Anzahl) Anfragen gleichzeitig bearbeiten.
Hier mal Beispielcode für nen Multithreaded Server:
Server-Code
http://wwwswt.informatik.uni-rostock...nerThread.java

Code von Worker-Thread:
http://wwwswt.informatik.uni-rostock...kerThread.java

[rand0m]

Danke für die schnelle Antwort!

Es sollte schon möglich sein, dass mehrere Client auf den Server zugreifen
Werd mal einen Multithreaded Server probieren.