旅行商求解器双线程实现：无需join()达成最优结果输出

Hey there! Let's figure out how to run your TSP solver's two threads (computation and UI) at the same time without relying on Thread.join(). The main thing here is to safely coordinate communication between the threads while following Swing's rules for UI updates—since all UI work has to happen on the Event Dispatch Thread (EDT).

1. Use Callback Interfaces for Result Handoff #

Define a callback that your computation thread triggers once it finishes calculating the optimal path and distance. This lets the UI react to the result as soon as it's ready, without blocking either thread.

Step 1: Define the Callback Interface #

public interface TspResultCallback {
    void onResultReady(String optimalPath, double totalDistance);
}

Step 2: Implement the Computation Thread with Callback #

Your TSP solver thread will take this callback and invoke it when done with calculations:

public class TspSolverThread extends Thread {
    private final TspResultCallback callback;
    // Add your TSP problem data (cities, distance matrix, etc.) here

    public TspSolverThread(TspResultCallback callback) {
        this.callback = callback;
    }

    @Override
    public void run() {
        // Execute your TSP optimization logic (e.g., brute force, genetic algorithm)
        String optimalPath = "City A → City B → City C → City A"; // Example result
        double totalDistance = 187.5; // Example distance

        // Pass the result to the callback (must update UI on EDT!)
        SwingUtilities.invokeLater(() -> {
            callback.onResultReady(optimalPath, totalDistance);
        });
    }
}

Step 3: Set Up the JFrame UI and Attach the Callback #

Your JFrame will implement the callback to update the display once the result is ready:

public class TspPathFrame extends JFrame implements TspResultCallback {
    private JLabel distanceLabel;
    private JPanel pathDrawingPanel;

    public TspPathFrame() {
        // Initialize UI components
        distanceLabel = new JLabel("Calculating optimal path...");
        pathDrawingPanel = new JPanel() {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                // Add your custom path drawing logic here later
            }
        };

        // Assemble the frame
        add(distanceLabel, BorderLayout.NORTH);
        add(pathDrawingPanel, BorderLayout.CENTER);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(600, 400);
        setVisible(true);
    }

    @Override
    public void onResultReady(String optimalPath, double totalDistance) {
        // Update UI with the computed result
        distanceLabel.setText(String.format("Optimal Distance: %.2f km", totalDistance));
        drawPath(optimalPath);
    }

    private void drawPath(String path) {
        // Implement your path drawing logic using Graphics2D here
        pathDrawingPanel.repaint();
    }
}

Step 4: Launch Both Threads Concurrently #

public class Main {
    public static void main(String[] args) {
        // Start the UI on the EDT (required for Swing to work safely)
        SwingUtilities.invokeLater(() -> {
            TspPathFrame frame = new TspPathFrame();
            
            // Start the TSP solver thread, passing the UI as the callback
            TspSolverThread solverThread = new TspSolverThread(frame);
            solverThread.start();
        });
    }
}

This approach keeps both threads running independently: the solver does its work in the background, and the UI stays responsive. When the solver finishes, it triggers the callback on the EDT to update the UI safely.

2. Use CompletableFuture for Async Task Management #

Java's CompletableFuture is a clean, modern way to handle asynchronous tasks without manual thread management. It handles result handoff seamlessly and avoids the need for join().

Example Implementation #

public class TspSolver {
    // Your core TSP solving method
    public static TspResult solveTsp() {
        // Execute your optimization logic here
        return new TspResult("City A → City B → City C → City A", 187.5);
    }

    // Helper class to hold results
    public static class TspResult {
        public final String path;
        public final double distance;

        public TspResult(String path, double distance) {
            this.path = path;
            this.distance = distance;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // Launch UI on EDT
        SwingUtilities.invokeLater(() -> {
            TspPathFrame frame = new TspPathFrame();
            
            // Run TSP solver asynchronously in a background thread
            CompletableFuture.supplyAsync(TspSolver::solveTsp)
                .thenAccept(result -> {
                    // Update UI on EDT once result is ready
                    SwingUtilities.invokeLater(() -> {
                        frame.updateResult(result.path, result.distance);
                    });
                });
        });
    }
}

// Updated TspPathFrame with a dedicated update method
public class TspPathFrame extends JFrame {
    private JLabel distanceLabel;
    private JPanel pathDrawingPanel;

    public TspPathFrame() {
        // Same UI initialization as before
        distanceLabel = new JLabel("Calculating optimal path...");
        pathDrawingPanel = new JPanel();
        add(distanceLabel, BorderLayout.NORTH);
        add(pathDrawingPanel, BorderLayout.CENTER);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(600, 400);
        setVisible(true);
    }

    public void updateResult(String path, double distance) {
        distanceLabel.setText(String.format("Optimal Distance: %.2f km", distance));
        drawPath(path);
    }

    private void drawPath(String path) {
        // Your custom path drawing logic here
        pathDrawingPanel.repaint();
    }
}

CompletableFuture.supplyAsync() runs the solver in a background thread from the common ForkJoinPool. The thenAccept() method triggers automatically when the result is ready, and we use SwingUtilities.invokeLater() to ensure UI updates happen on the EDT. No join() needed—everything is handled via async callbacks.

3. Thread-Safe Shared State (With Caution) #

If you prefer a shared data structure, use a thread-safe object to hold the result. The computation thread writes to it when done, and the UI can listen for changes or check periodically (though listening is more efficient).

Example with AtomicReference #

public class Main {
    public static void main(String[] args) {
        AtomicReference<TspSolver.TspResult> resultRef = new AtomicReference<>();
        
        // Launch UI on EDT
        SwingUtilities.invokeLater(() -> {
            TspPathFrame frame = new TspPathFrame();
            
            // Timer to check for result updates every 100ms
            Timer timer = new Timer(100, e -> {
                TspSolver.TspResult result = resultRef.get();
                if (result != null) {
                    frame.updateResult(result.path, result.distance);
                    ((Timer) e.getSource()).stop(); // Stop checking once result is ready
                }
            });
            timer.start();
        });
        
        // Start solver thread
        new Thread(() -> {
            TspSolver.TspResult result = TspSolver.solveTsp();
            resultRef.set(result); // Write result to thread-safe reference
        }).start();
    }
}

This works, but the timer approach is less efficient than callbacks or CompletableFuture. Stick to the first two methods for cleaner, more responsive code.

Key Takeaways #

• Always update Swing UI on the EDT: Use SwingUtilities.invokeLater() for any UI changes triggered by background threads.
• Avoid blocking threads: Callbacks and CompletableFuture let threads run independently without join().
• Prioritize thread safety: If using shared state, use thread-safe objects like AtomicReference or synchronized blocks to prevent race conditions.

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