Java 如何为目前在for循环中完成的一系列操作实现forkjoin

我有一个发件人列表，我必须单独并行发送邮件。目前，我正在遍历该列表构造正文（因为不同的人有不同的正文），然后发送它们。如何使用forkjoin进行此操作。我尝试过使用RecursiveAction，但我想它只适用于递归任务

---

internet上所有可用的示例都是用递归操作实现的。是否还有其他类可以实现此功能。

ServiceExecutor可以很好地实现此功能。它们与Java一起提供

import java.util.*;
import java.util.concurrent.*;

public class SendMailExample
{
  public static void main(String[] args) throws Exception
  {
    ExecutorService executor = Executors.newFixedThreadPool(3);

    Collection<Future> futures = new ArrayList<Future>();
    futures.add(executor.submit(new Mailer("thread1")));
    futures.add(executor.submit(new Mailer("thread2")));
    futures.add(executor.submit(new Mailer("thread3")));

    for (Future future : futures)
    {
      future.get();
    }
    executor.shutdown();
  }

  static class Mailer implements Runnable
  {
    private Object message;

    public Mailer(Object message)
    {
      this.message = message;
    }

    public void run()
    {
      System.out.println("Sending message " + String.valueOf(message));
    }
  }
}

import java.util.*；
导入java.util.concurrent.*；
公共类SendMailExample
{
公共静态void main（字符串[]args）引发异常
{
ExecutorService executor=Executors.newFixedThreadPool（3）；
集合期货=新的ArrayList（）；
futures.add（executor.submit）（新邮件（“thread1”））；
futures.add（executor.submit）（新邮件（“thread2”））；
futures.add（executor.submit）（新邮件（“thread3”））；
for（未来：未来）
{
future.get（）；
}
executor.shutdown（）；
}
静态类Mailer实现可运行
{
私有对象消息；
公共邮件程序（对象消息）
{
this.message=消息；
}
公开募捐
{
System.out.println（“发送消息”+String.valueOf（消息））；
}
}
}

我浏览了一下，得到了一个更好的答案：

package Test1;

import java.util.*;
import java.util.concurrent.*;
import static java.util.Arrays.asList;

public class Sums
{
    static class Sum implements Callable<Long>
    {
        private final long from;
        private final long to;
        Sum(long from, long to)
        {
            this.from = from;
            this.to = to;
        }

        @Override
        public Long call()
        {
            long acc = 0;
            if(from == 0)
            {
                try
                {
                    Thread.sleep(5000);
                }
                catch (InterruptedException e)
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            System.out.println(from);
            for (long i = from; i <= to; i++)
            {
                acc = acc + i;
            }
            return acc;
        }                
    }

    public static void main(String[] args) throws Exception
    {
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        List <Future<Long>> results = executor.invokeAll(asList(
        new Sum(0, 10), new Sum(100, 1000), new Sum(10000, 1000000)
        ));
        executor.shutdown();

        for (Future<Long> result : results)
        {
            System.out.println(result.get());
        }
    }    
}

包测试1；
导入java.util.*；
导入java.util.concurrent.*；
导入静态java.util.Arrays.asList；
公共类金额
{
静态类Sum实现了可调用
{
私人最终长从；
私人最终长到；
总和（长起，长至）
{
this.from=from；
这个；
}
@凌驾
公共长途电话（）
{
长acc=0；
if（from==0）
{
尝试
{
睡眠（5000）；
}
捕捉（中断异常e）
{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
System.out.println（from）；
（长i=从；i）