java - 线程模板

Question

好的，我有一个 GUI Java 应用程序，允许用户选择并启动 5-500 个软件设备，每个软件设备由一个线程表示。线程不断更新 GUI 的信息。

用户可以选择线程并暂停、恢复或终止它们。

关于线程和线程池、中断、Future 的所有信息...我刚刚迷路了，想要点燃互联网 =)

我需要的是关于标准前进方向的一些明确指导。我的线程类的大纲如下。

这是一个很好的开始模板吗？如果没有，请编辑。

package ACsimForm;

import java.util.Random;
import javax.swing.SwingUtilities;

public class Squeak implements Runnable {

    private  String name = "";  
    private  javax.swing.JTextArea ScroolPage;


        Squeak (String name, javax.swing.JTextArea MW )
        {
            this.value = true;
            this.name = name;
            this.ScroolPage = MW;
        }


         Random r = new Random();
         int num = r.nextInt(10-1) + 1;


    @Override
   public void run ()
        {                                 
            updateGUI("Thread "+name+" Loaded and Running");

            while(true)
            {
                updateGUI("New Data");

                try {                        
                      TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {
                    updateGUI("Thread "+name+" Exiting!");
                    //return exits the method killing the thread
                    return;
                }                
            }                               
        }



 //this is the new way to communicate back to the GUI 
 private void updateGUI(final String foo) {
 SwingUtilities.invokeLater(new Runnable() {
        @Override
        public void run() {
          ScroolPage.append(foo+"\r\n");      
        }
      });
    }
    }

保持最多 500 个线程并允许您从 GUI 终止或暂停/恢复它们的最佳方法是什么？

非常感谢。

Answer 1

我认为你的Runnable快到了。放弃魔法的想法Boolean flag - 这受到问题的困扰(阅读 volatile )。使用中断本身作为信号。这就是它存在的原因!

这是一个具有任意数量 Thread 的系统的简单示例s:

private static final class Printer implements Runnable {

    private final String printMe;

    public Printer(String printMe) {
        this.printMe = printMe;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName() + "says: " + printMe);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException ex) {
                return;
            }
        }
    }
}

public static void main(String[] args) throws Exception {
    final ExecutorService executorService = Executors.newCachedThreadPool();
    final Map<Integer, Future<?>> futures = new HashMap<>();
    for (int i = 0; i < 10; ++i) {
        futures.put(i, executorService.submit(new Printer("Printer" + i)));
    }
    final Scanner scanner = new Scanner(System.in);
    while (true) {
        final String input = scanner.nextLine();
        if ("EXIT".equalsIgnoreCase(input)) {
            break;
        }
        final Integer threadToStop;
        try {
            threadToStop = Integer.parseInt(input);
        } catch (NumberFormatException ex) {
            System.out.println("Not a number");
            continue;
        }
        final Future<?> f = futures.remove(threadToStop);
        if (f == null) {
            System.out.println("Not a valid thread");
            continue;
        }
        f.cancel(true);
    }
    executorService.shutdownNow();
}

我们使用 ExecutorService管理Thread s - 你永远不应该使用Thread直接，这里又被地雷困扰了。

ExecutorService被要求运行任意数量的任务 - 您可以在 for 中查看如何添加任务循环。

然后ExecutorService返回 Future对于添加的每个任务 - 这些是任务的句柄。它们允许我们检查它们是否仍在进行/完成或遇到错误。

我们Map Future s 到任务名称，并允许用户有选择地从输入中终止任务。

您无法“暂停”和“恢复”Thread (好吧，你可以，但你最好不要担心这一点)。当您想要暂停任务时，您只需取消任务，然后重新发出它即可重新启动它。好处是ExecutorService将回收Thread任务正在运行，因此您不会损失性能。

如果您向 Map 发出命令的Future来自多个线程，您将需要 ConcurrentHashMap .

一个常见的陷阱是假设您的应用程序将完全退出并显示 ExecutorService运行。不是这种情况。 ExecutorService产生非守护线程，因此应用程序在它们全部完成之前无法退出。你有两个选择；第一个有点 hacky - 只需给出 ExecutorService你自己的ThreadFactory并制作 Thread s 守护进程，第二个是关闭ExecutorService当你完成它时，就像我在示例中所做的那样。