Java Thread Klasse liefert falschen Rückgabewert. Woran liegt das?

... komplette Frage anzeigen

3 Antworten

Spiele über das Netzwerk sind schon eine Interessante Sache. 

Eigentlich allgemein die Kommunikation zwischen Server und Client.

Aber zu deiner Frage:

Wieso sind sind die beiden Variablen:  verbundenA / verbundenB immer auf false obwohl diese eigentlich auf true gesetzt waren.

Leider muss ich sagen, dass mir bei deinem Code Beispiel entsprechendes fehlt um das erkennen zu können, sprich: Wo Deklarierst du die beiden Variablen? 

Hier wäre z.b. die vollständige Serverklasse Interessant, bzw, die Stellen der deklaration und die Stellen der getter/setter

Sowie: In welcher Klasse frägst du dann den Zustand der Variablen ab? Du meinst ja nicht zufällig in derselben Schleife in der du sie setzt oder?

Antwort bewerten Vielen Dank für Deine Bewertung
Kommentar von Azazin
18.02.2016, 22:35

package battleship;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;

public class Server implements Runnable {
Socket clientA;
Socket clientB;

static volatile boolean verbundenA = false;
static volatile boolean verbundenB = false;

static volatile AtomicBoolean peter = new AtomicBoolean(true);

public Server() {

}

// public void incrementCount() {
// synchronized (gfx.class) {
// verbundenB = true;
// }
// }

public void run() {

System.out.println("Run vom Server");

ExecutorService executor = Executors.newFixedThreadPool(2);

ServerSocket server;

try {

server = new ServerSocket(1337);
System.out.println("Server ist gestartet.\n");

while (!(verbundenA && verbundenB)) {
try {
if (!verbundenA) {
clientA = server.accept();
verbundenA = true;
}
if (!verbundenB) {
clientB = server.accept();
// incrementCount();
verbundenB = true;

}
} catch (IOException e1) {

}
}

} catch (IOException e1) {

}

System.out.println("Clients sind verbunden.");
executor.execute(new Trader("Client 1", clientA, clientB));
System.out.println("client 1 Handler gestartet");
executor.execute(new Trader("Client 2", clientB, clientA));
System.out.println("client 2 Handler gestartet");

peter.set(false);

}

public static void main(String[] args) {

Thread t1 = new Thread(new Server());

System.out.println("ServerThread gestartet");
t1.start();

}

public boolean isVerbundenA() {
return verbundenA;
}

public boolean isVerbundenB() {
return verbundenB;
}

}

btnHost.addActionListener(e -> {

server = new Server();
server.main(null);
client = new Client(true, textField.getText());
client.main(null);

btnHost.setVisible(false);
btnJoin.setVisible(false);
lblWarte.setVisible(true);

Thread thread = new Thread() {
public void run() {
boolean f = false;
while (!f) {
try {
TimeUnit.SECONDS.sleep(1);
System.out.println("Zweiter Client verbunden: " + booo(server.isVerbundenB()));
if (server.isVerbundenB()) {
f = true;
}
} catch (InterruptedException e) {
// Handle exception
}
}
System.out.println("Zweiter Client ist Verbunden!");
lblWarte.setVisible(false);
init();
}
};
thread.start();

});

Die Server Klasse und die Actionlistener vom Host sind eigentlich das Wichtigste. :D

0
  1. Wo startest du den Server?
  2. Ein Observer-Pattern wäre evt. passender, die einkommenden Clients speicherst du in einer Liste

Antwort bewerten Vielen Dank für Deine Bewertung
Kommentar von Azazin
18.02.2016, 21:37

1. Ganz oben beim ersten Codeausschnitt.

2. Bei zwei Clients lohnt das nicht.

0

verbundenA und verbundenB müssen volatile sein.

Antwort bewerten Vielen Dank für Deine Bewertung
Kommentar von Azazin
18.02.2016, 21:35

Danke für die Antwort, aber mit volatile hat es nicht funktioniert. :o

0

Was möchtest Du wissen?