Java: Multithreading & Socket UDP Programmation

Première chose est d'abord: vos classes doit commencer avec une lettre majuscule par la Conventions De Nommage Java:

Les noms de classe doivent être des noms, en majuscules et en minuscules avec la première lettre de
interne de chaque mot en majuscule. Essayez de
gardez vos noms de classe simple et
descriptive. Utilisez des mots-éviter
les acronymes et les abréviations (sauf le
l'abréviation est beaucoup plus largement utilisé
que la forme longue, tels que les URL ou
HTML).

Deuxième:
Essayez de diviser le code en sections cohérentes et de les organiser autour de quelques caractéristique commune qui vous avez affaire... peut-être autour de la fonctionnalité ou le modèle de programmation.

L' (de base) pour le modèle de serveur, c'est que le seulement chose qu'il fait est de recevoir des connexions socket... le serveur s'appuie sur un gestionnaire pour gérer les connexions et c'est tout. Si vous essayez de construire ce modèle, il ressemblerait à quelque chose comme ceci:

class Server{
private final ServerSocket serverSocket;
private final ExecutorService pool;
public Server(int port, int poolSize) throws IOException {
serverSocket = new ServerSocket(port);
pool = Executors.newFixedThreadPool(poolSize);
}
public void serve() {
try {
while(true) {
pool.execute(new Handler(serverSocket.accept()));
}
} catch (IOException ex) {
pool.shutdown();
}
}
}
class Handler implements Runnable {
private final Socket socket;
Handler(Socket socket) { this.socket = socket; }
public void run() {
//receive the datagram packets
}
}

Troisième: je vous recommande de regarder quelques exemples existants.

• Multi-thread Applications Client/Serveur:
  
  http://www.ase.md/~aursu/ClientServerThreads.html
• Doug Lea:
  
  http://www.developer.com/java/ent/article.php/3645111/Java-5s-BlockingQueue.htm (merci à John)
  
  http://gee.cs.oswego.edu/dl/cpj/index.html (ne trouvez toujours pas l'exemple précis, mais il est là quelque part... si vous vous sentez courageux regarder par-dessus son allcode.java fichier).
• De la simultanéité dans la Pratique, exemples:
  
  http://www.javaconcurrencyinpractice.com/listings.html
• Java Simultanéité Des Tutoriels:
  
  http://java.sun.com/docs/books/tutorial/essential/concurrency/

Mis à jour par commentaires:

OK Ravi, il y a quelques grand des problèmes avec votre code et mineur problèmes avec elle:

1. Je suppose que le Receive classe est votre client..., vous devez tirer que comme un programme distinct (avec sa propre classe principale) et exécuter votre serveur et plusieurs clients en même temps. Lançant un nouveau "thread client" de votre serveur pour chaque nouveau paquet UDP que vous envoyez est une fâcheuse idée (grand question).

2. Lorsque vous effectuez votre application cliente, vous devez faire tourner la réception de code dans sa propre while boucle (mineur de l'émission), par exemple:

   public class Client extends Thread
   {
   public Client(/*..*/)
   {
   //initialize your client
   }
   public void run()
   {
   while(true)
   {
   //receive UDP packets
   //process the UDP packets
   }
   }
   public static void main(String[] args) throws IOException
   {
   //start your client
   new Client().start();
   }
   }

3. Vous ne devriez juste besoin d'un thread par client et un thread par serveur (vous, techniquement, ne sont pas même d'un autre thread là depuis principale a son propre thread), de sorte que vous pouvez ne pas trouver le ExecutorService que utile.

Sinon, votre approche est correcte... mais je encore vous recommandons de consulter quelques exemples.

OriginalL'auteur

C'est une bonne chose de l'Éclipse de l'histoire des œuvres, même pour un jour de retour 🙂 Merci, je suis en mesure de donner à la fois Ravi un exemple de travail et de Lirik sa réponse en fuite.

Laissez-moi d'abord commencer par disant que je n'ai aucune idée de ce qui est à l'origine de cette fuite, mais si je le laisse suffisamment longtemps, il va échouer sur un OutOfMemoryError.

Deuxième, j'ai laissé le code de travail en commentaire pour Ravi pour un exemple de base de mon serveur UDP. Le délai d'attente est là pour tester combien de temps mon pare-feu de tuer les récepteurs fin (30 secondes). Juste enlever quoi que ce soit à la piscine, et vous êtes bon pour aller.

Donc, ici, c'est un travail mais une fuite de la version de mon exemple filetée UDP serveur.

public class TestServer {
private static Integer TIMEOUT = 30;
private final static int MAX_BUFFER_SIZE = 8192;
private final static int MAX_LISTENER_THREADS = 5;
private final static SimpleDateFormat DateFormat = new SimpleDateFormat("yyyy-dd-MM HH:mm:ss.SSSZ");
private int mPort;
private DatagramSocket mSocket;
//You can remove this for a working version
private ExecutorService mPool;
public TestServer(int port) {
mPort = port;
try {
mSocket = new DatagramSocket(mPort);
mSocket.setReceiveBufferSize(MAX_BUFFER_SIZE);
mSocket.setSendBufferSize(MAX_BUFFER_SIZE);
mSocket.setSoTimeout(0);
//You can uncomment this for a working version
//for (int i = 0; i < MAX_LISTENER_THREADS; i++) {
// new Thread(new Listener(mSocket)).start();
//}
//You can remove this for a working version
mPool = Executors.newFixedThreadPool(MAX_LISTENER_THREADS);
} catch (IOException e) {
e.printStackTrace();
}
}
//You can remove this for a working version
public void start() {
try {
try {
while (true) {
mPool.execute(new Listener(mSocket));
}
} catch (Exception e) {
e.printStackTrace();
}
} finally {
mPool.shutdown();
}
}
private class Listener implements Runnable {
private final DatagramSocket socket;
public Listener(DatagramSocket serverSocket) {
socket = serverSocket;
}
private String readLn(DatagramPacket packet) throws IOException {
socket.receive(packet);
return new BufferedReader(new InputStreamReader(new ByteArrayInputStream(packet.getData())), MAX_BUFFER_SIZE).readLine();
}
private void writeLn(DatagramPacket packet, String string) throws IOException {
packet.setData(string.concat("\r\n").getBytes());
socket.send(packet);
}
@Override
public void run() {
DatagramPacket packet = new DatagramPacket(new byte[MAX_BUFFER_SIZE], MAX_BUFFER_SIZE);
String s;
while (true) {
try {
packet = new DatagramPacket(new byte[MAX_BUFFER_SIZE], MAX_BUFFER_SIZE);
s = readLn(packet);
System.out.println(DateFormat.format(new Date()) + " Received: " + s);
Thread.sleep(TIMEOUT * 1000);
writeLn(packet, s);
System.out.println(DateFormat.format(new Date()) + " Sent: " + s);
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
if (args.length == 1) {
try {
TIMEOUT = Integer.parseInt(args[0]);
} catch (Exception e) {
TIMEOUT = 30;
}
}
System.out.println(DateFormat.format(new Date()) + " Timeout: " + TIMEOUT);
//new TestServer(4444);
new TestServer(4444).start();
}
}

btw. @Lirik, j'ai été témoin de ce comportement tout d'abord dans Eclipse, après quoi je l'ai testé à partir de la ligne de commande. Et encore, je n'ai PAS la moindre idée de ce qui en est la cause 😉 désolé...

OriginalL'auteur djBo