Question

我正在尝试拥有一堆可以一次启动的可运行线程。像

这样的东西

First(new Thread() {
    public void run() {
        //do something

    }
});

我想做的不可能吗？

Answer 1

您可以使用单线程执行程序

ExecutorService service = Executors.newSingleThreadedPool();

service.submit(runnable1);
service.submit(runnable2);
service.submit(runnable3);

Answer 2

是的，只有多个私有方法：

public class FirstCaller {

   private void method1() { }
   private void method2() { }
   private void method3() { }

    public void someMethod() {
        First(new Thread() {
           public void run() {
                //do something
                method1();
                method2();
                method3();
            }
        });
    }
}

或者如Ted Hopp所指出的那样

public class FirstCaller {
        public void someMethod() {
            new First(new Thread() {
               private void method1() { }
               private void method2() { }
               private void method3() { }

               public void run() {
                    //do something
                    method1();
                    method2();
                    method3();
                }
            });
        }
    }

Answer 3

如果您想同时启动几个线程，CountDownLatch就是您所需要的。请在此处查看示例：http://www.javamex.com/tutorials/threads/CountDownLatch.shtml。

Answer 4

我想在一个线程中有几个runnable。他们会在不同的时间做不同的事情。

我迟到了这个讨论，但这听起来像是一个糟糕的设计。如果你的班级在不同的时间做不同的事情，那么它应该分成不同的类。

如果您正在谈论重复使用相同的背景线程来做不同的事情，那么我会使用单个线程池，如@ Peter的回答：

private ExecutorService threadPool = Executors.newSingleThreadedPool();
...
threadPool.submit(new First());
threadPool.submit(new Second());
threadPool.submit(new Third());
...
// when you are done submitting, always shutdown your pool
threadPool.shutdown();

First，Second和Third类将实现Runnable。如果他们需要共享一些状态，他们可以采用构造函数参数。

Answer 5

您是否尝试在单个线程中按顺序执行多个runnable？一个接一个？

public class MultiRunnable implements Runnable {

    private Runnable runnable1;
    private Runnable runnable2;


    public MultiRunnable(Runnable runnable1, Runnable runnable2) {
        this.runnable1 = runnable1;
        this.runnable2 = runnable2;
    }

    @Override
    public void run() {
        runnable1.run();
        runnable2.run();
    }
}

然后，您可以致电(new Thread(new MultiRunnable(... , ...))).start();

这将首先执行第一个Runnable，当它完成时，它将执行第二个。

或者推广到更多Runnables：

import java.util.Arrays;
import java.util.List;

public class MultiRunnable implements Runnable {

    private List<Runnable> runnables;

    public MultiRunnable(Runnable... runnables) {
        this.runnables = Arrays.asList(runnables);
    }
    public MultiRunnable(List<Runnable> runnables) {
        this.runnables = runnables;
    }

    @Override
    public void run() {
        for(Runnable runnable : runnables)
            runnable.run();
    }
}

Answer 6

最简单的方法是定义几个Thread子类实例，并根据您要执行的操作调用相应的实例。

但是，如果您确实需要一个在不同情况下表现不同的Thread个对象，则可以定义一个Thread子类，该子类具有一个状态变量来控制它的作用。

class MyThread extends Thread {
    public enum Action { A, B, C }
    private Action mAction;
    public void run() {
        if (mAction == null) {
            throw new IllegalStateException("Action must be specified");
        }
        switch (mAction) {
        case A:
            methodA();
            break;
        case B:
            methodB();
            break;
        case C:
            methodC();
            break;
        }
    }
    public void setAction(Action action) {
        if (action == null) {
            throw new IllegalArgumentException("Action cannot be null");
        }
        mAction = action;
    }
    private void methodA() { ... }
    private void methodB() { ... }
    private void methodC() { ... }
}

然后您可以创建线程，在致电start()之前，请致电setAction，传递其中一个Action值。

作为状态变量的替代方法，run()方法可以检查外部变量以确定操作的选择。这是否有意义（以及是否会更好）取决于您的应用程序。

单个线程中的多个Runnable -java

6 个答案: