java中的执行器服务-->如何将单线程代码转换为使用执行器

Question

如果这个问题听起来很傻，请原谅——我刚刚开始使用Executor。

我有一个现有的java应用程序，它以这种方式使用线程——基本上使用独立的线程——

private Thread spawnThread( )
    {
        Thread t = new Thread()
        {
            String taskSnap = task.toString();
            public void run()
            {
                try
                {
                    println( task.run( null ) );
                }catch( InterruptedException e )
                {
                    println( "ITC - " + taskSnap + " interrupted " );
                }
            }
        };
        return t;
    }

正如您从上面看到的，该函数返回一个新线程。

现在，在程序的main（）函数中，以这种方式创建了一个新线程——

    taskThread = spawnThread();
    taskThread.start();

我想做的是，创建一个执行器服务（具有固定数量的线程）-->，然后将创建新线程/由新线程执行任务的任务移交给该执行器。

由于我是Executor的新手，我想知道的是，我如何更改上面的代码，以便在线程池中创建一个新线程，而不是形成一个新的单独线程。我看不到任何创建线程的命令（在线程池中）-->将上述任务交给该线程（而不是如上所述的独立线程）。

请告诉我如何解决这个问题。

Answer 1

在您的main中，您可以编写如下内容：

ExecutorService executor = Executors.newFixedThreadPool(nThreads);
executor.submit(new Runnable() {
    String taskSnap = task.toString();
    public void run() {
            try {
                println(task.run(null));
            } catch( InterruptedException e) {
                println("ITC - " + taskSnap + " interrupted ");
            }
    }
});

submit方法将在executor服务中的一个线程上执行Runnable。

注意：当你不再需要执行器服务时，不要忘记关闭它，否则它会阻止你的程序退出。

Answer 2

提问前先做调查。其想法是创建一个实现Runnable的类，并使用executor服务执行它。

示例来自：Java并发（多线程）-教程

工作者的实现（实现Runnable）：

package de.vogella.concurrency.threadpools;
/** * MyRunnable will count the sum of the number from 1 to the parameter * countUntil and then write the result to the console. * <p> * MyRunnable is the task which will be performed * * @author Lars Vogel * */
public class MyRunnable implements Runnable {
  private final long countUntil;
  MyRunnable(long countUntil) {
    this.countUntil = countUntil;
  }
  @Override
  public void run() {
    long sum = 0;
    for (long i = 1; i < countUntil; i++) {
      sum += i;
    }
    System.out.println(sum);
  }
} 

如何使用executor服务来运行触发器工作线程

package de.vogella.concurrency.threadpools;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
  private static final int NTHREDS = 10;
  public static void main(String[] args) {
    //You can also use Executors.newSingleThreadExecutor() if you just need 1 thread
    ExecutorService executor = Executors.newFixedThreadPool(NTHREDS);
    for (int i = 0; i < 500; i++) {
      Runnable worker = new MyRunnable(10000000L + i);
      executor.execute(worker);
    }
    // This will make the executor accept no new threads
    // and finish all existing threads in the queue.
    executor.shutdown();
    // Wait until all threads are finish
    //while (!executor.isTerminated()) {
    //}
    //System.out.println("Finished all threads");
    //All the threads might not be finished at this point of time. Thread endtime purely depends on the time taken by the processing logic inside your thread.
  }
} 

Answer 3

你的意思是这样的吗？

class Parallel {
    private ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    public void shutdown() {
        pool.shutdown();
    }
    public void foo() {
        pool.submit(new Runnable() {
            @Override
            public void run() {
                // put your code here
            }
        });
    }
}