Ping mehrere Server in Java

Question

Ich habe ein Programm, das eine Ping-Anfrage an die Server sendet. Die Liste ist groß und wenn ein IP nicht erreichbar ist, braucht es Zeit, um zum nächsten IP zu gehen.

Ich wünsche, dass für alle IP, sollte es einen neuen Thread erstellen & alle gleichzeitig verarbeiten. Hier

ist der Code:

for (int i = 0; i < 89; i++) 
{ 
    ProcessBuilder processBuilder = new ProcessBuilder("ping", isWindows? "-n" : "-c", "1", buttons[i].getText()); 
    Process proc = processBuilder.start(); 
    returnVal = proc.waitFor();      
} 

Wie kann ich diesen Code machen alle IP s ping, die jeweils in einem eigenen Thread?

Answer 1

Wie wäre es mit ohne ProcessBuilder wie von anderen auch vorgeschlagen.

Ich habe drei Klassen - PingParallel ist meine Hauptklasse, PingTask die Aufgabe von jedem Thread ausgeführt ist, und PingResult ist Ergebnis Code (wir haben auch ein paar mehr Infos hinzufügen können, Statusmeldung etc.).

PingParallel

package com.test.thread; 

import java.util.ArrayList; 
import java.util.Date; 
import java.util.List; 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Future; 

public class PingParallel { 

    public static void main(String[] args) { 
     int totalIps = 89; 
     ExecutorService executor = Executors.newFixedThreadPool(totalIps); 
     List<Future<PingResult>> list = new ArrayList<Future<PingResult>>(); 
     Callable<PingResult> callable = null; 
     for(int i=0; i< totalIps; i++){ 
      callable = new PingTask("127.0.0"+i); // Get the ipAddres buttons[i].getText()); 
      Future<PingResult> future = executor.submit(callable); 
      list.add(future); 
     } 
     for(Future<PingResult> fut : list){ 
      try { 
       System.out.println(new Date()+ "::"+fut.get()); 
      } catch (Exception e) { 
       e.printStackTrace(); 
      } 
     } 
     executor.shutdown(); 
    } 
} 

PingTask

package com.test.thread; 

import java.net.InetAddress; 
import java.util.concurrent.Callable; 

public class PingTask implements Callable<PingResult> { 

    private String ipAddress; 

    public PingTask(String ipAddress) { 
    this.ipAddress = ipAddress; 
    } 

    @Override 
    public PingResult call() { 
    InetAddress inet = null; 
    try { 
     inet = InetAddress.getByName(ipAddress); 
     int resultCode = inet.isReachable(5000) ? 0 : -1; 
     return new PingResult(ipAddress, resultCode); 
    } catch (Exception e) { 
     e.printStackTrace(); 
     return new PingResult(ipAddress, -1); 
    } 
    } 
} 

PingResult

package com.test.thread; 

public class PingResult { 

    private String ipAddress; 
    private int resultCode; 

    public PingResult(String ipAddress, int resultCode) { 
    this.ipAddress = ipAddress; 
    this.resultCode = resultCode; 
    } 

    public String getIpAddress() { 
    return ipAddress; 
    } 

    public int getResultCode() { 
    return resultCode; 
    } 

    public String toString() { 
    return "IpAddress :: "+ ipAddress + " Result Code : "+ resultCode; 
    } 
} 

Answer 2

ProcessBuilder ruft einen neuen Prozess auf, aber Sie beenden die Parallelität effektiv, indem Sie waitFor aufrufen, da dies darauf wartet, dass der erste Prozess abgeschlossen wird, bevor der nächste Prozess gestartet wird. Sie könnten entweder PB verwenden und die Warteaufrufe überspringen oder stattdessen normale Java-Threads verwenden, die Aufrufe an Runtime.exec umhüllen.