如何高效并行执行实现Callable接口的类？求助优化CheckCon执行效率

Hey there! Let’s break down how to fix your slow network device scanning with Callable and get results back to NetScan.java efficiently. The issue likely isn’t just the thread count—it’s how you’re managing threads and handling the network checks themselves. Here’s a step-by-step solution:

Creating 25 separate threads manually is inefficient—each thread has overhead for initialization and teardown. Instead, use a fixed-size thread pool to reuse threads, which cuts down on unnecessary resource usage. This is perfect for network-bound tasks like device scanning.

Since your CheckCon implements Callable<Integer>, each task returns a Future<Integer> that holds the result of whether a device is connected. Using ExecutorService.invokeAll() lets you submit all tasks at once and wait for all to complete, which is far cleaner than tracking threads individually.

Most slowdowns in network scanning come from overly long timeouts or inefficient connectivity checks. Tweak these to speed things up:

• Set a reasonable timeout: InetAddress.isReachable() defaults to a long timeout—use 1000-2000ms instead of the default 3000ms.
• Use faster check methods: isReachable() can be slow; try connecting to a common open port (like 80 or 443) via TCP for quicker responses (note: some devices may block these ports, so balance with ping checks if needed).
• Avoid redundant checks: Ensure you’re not scanning duplicate IPs or ranges that don’t exist in your network.

Here’s how to wire this all together between CheckCon.java and NetScan.java:

CheckCon.java (Callable Implementation) #

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

public class CheckCon implements Callable<Integer> {
    private final String ipAddress;
    private final int timeout;

    public CheckCon(String ipAddress, int timeout) {
        this.ipAddress = ipAddress;
        this.timeout = timeout;
    }

    @Override
    public Integer call() {
        try {
            InetAddress device = InetAddress.getByName(ipAddress);
            // Check if the device is reachable with the set timeout
            if (device.isReachable(timeout)) {
                return 1; // Count this as a connected device
            }
        } catch (Exception e) {
            // Ignore exceptions (e.g., unknown host, connection refused)
        }
        return 0; // Device not connected or unreachable
    }
}

NetScan.java (Orchestrating the Scan) #

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

public class NetScan {
    public static void main(String[] args) {
        // Define your network IP range (adjust to match your network)
        List<String> targetIps = generateIpRange("192.168.1", 1, 254);
        int optimalThreadCount = Runtime.getRuntime().availableProcessors() * 3; // IO-bound tasks benefit from more threads
        int scanTimeout = 1500; // 1.5 seconds per check (adjust based on your network)

        // Initialize thread pool
        ExecutorService executor = Executors.newFixedThreadPool(optimalThreadCount);
        List<Callable<Integer>> scanTasks = new ArrayList<>();

        // Add all scan tasks to the list
        for (String ip : targetIps) {
            scanTasks.add(new CheckCon(ip, scanTimeout));
        }

        int connectedDeviceCount = 0;
        try {
            // Submit all tasks and wait for results
            List<Future<Integer>> results = executor.invokeAll(scanTasks);
            
            // Tally up the connected devices
            for (Future<Integer> result : results) {
                connectedDeviceCount += result.get();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // Shutdown the executor to free resources
            executor.shutdown();
        }

        // Use the result in your NetScan logic
        System.out.println("Total connected devices: " + connectedDeviceCount);
    }

    // Helper method to generate a list of IP addresses in a range
    private static List<String> generateIpRange(String baseIp, int start, int end) {
        List<String> ips = new ArrayList<>();
        for (int i = start; i <= end; i++) {
            ips.add(baseIp + "." + i);
        }
        return ips;
    }
}

• Adjust thread count: For network-bound tasks, thread count can safely be 2-4x your CPU core count (we used 3x in the example). Test different values to find what works best for your network.
• Parallelize IP ranges: Split your IP list into chunks and process each chunk with a sub-pool if you’re scanning a very large range.
• Use non-blocking IO: For extreme performance, consider using NIO-based scanning libraries, but that’s more advanced—start with the above first.

内容的提问来源于stack exchange，提问作者Anshul