ForkJoinPool的使用

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/cdw8131197/article/details/62893209

我在工作中遇到过这样一个问题,是给网站用户发送营销短信。我记得我们网站会员大约有7万个,要给这7万个用户发送营销短信。而短信运营商那边要求每次发送的手机号码最好要少于3000。
那时候的我,没有什么经验,不会使用多线程,将整个程序顺序写下来,大体思路如下:

这里写图片描述

这样做的后果,整个完成7万条短信的发送,需要10多分钟。最要命的是,当时我们使用nignx,或许是没配置好的原因,当一个程序执行超过6分钟没有完成时,则会自动重新执行。所以很悲剧的是我们给每个会员都发送了两条一模一样的短信。有的会员还好心的告诉我们客服,说是短信发重复了。感觉那段时间压力很大,没法跟公司老总交代了。老总还比较好,念在我是新员工的份上,没有追究责任。

然后怎么办?改呗,通过这件事,我第一次自己使用了多线程,以前只是听说,并没有真正用到,甚至都没有考虑过什么时候用它。

思路很简单,也是将list,3000条分一次,只不过不用主程序去发送短信,而是new Thread()去发送短信。在后来的优化中,又将new Thread()优化成了线程池。

每次公司发送营销短信的时候,我都提心吊胆的。生怕某个线程执行的时候出现什么问题。

后来即使换了公司,我还时常想起这件事情,总是想我的代码还可以在优化。偶然的机会,我接触了ForkJoinPool。若是我还在以前的公司,我一定要用ForkJoinPool去试一下,可不可以。

ForkJoinPool

ForkJoinPool线程池思想:将大任务分解成若干个小任务,当小任务均执行结束后,将任务做一个整合,在网上盗了一张图
这里写图片描述

使用接口:
RecursiveAction:没有返回值,只是执行任务
RecursiveTask:有返回值,小任务结束后,返回结果。大任务可将小任务返回结果进行整合

用ForkJoinPool完成上述发送短信功能

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.TimeUnit;

public class SendMessageTask extends RecursiveAction{


    // 每个“小任务”只最多只给10名用户发送短信
    private static final int THRESHOLD = 10;
    private int start;
    private int end;
    List<String> list = null;
    // 从start到end的任务
    public SendMessageTask(int start, int end,List<String> list)
    {
        this.start = start;
        this.end = end;
        this.list = list;
    }

    @Override
    protected void compute() {
        // TODO Auto-generated method stub
        if(end - start < THRESHOLD){
            String mobileno="";
            for (int i = start ; i < end ; i++ )
            {
                 //此处做手机号码累加,用于发送给短信运营商
                 mobileno+=list.get(i)+","
            }
            System.out.println("给手机号码=="+mobileno+"的用户发送手机短信");
        }else{
            // 如果当end与start之间的差大于THRESHOLD时,即要发送的数超过10个
            // 将大任务分解成两个小任务。
            int middle = (start + end) /2;
            SendMessageTask left = new SendMessageTask(start, middle,list);
            SendMessageTask right = new SendMessageTask(middle, end,list);
            // 并行执行两个“小任务”
            left.fork();
            right.fork();
        }

    }

    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for(int i=1;i<=380;i++){
            list.add("i------"+i);//假设此处为手机号码--项目中从数据库中获取
        }
        ForkJoinPool pool = new ForkJoinPool();
        // 提交可分解的PrintTask任务
        pool.submit(new SendMessageTask(0 , list.size(),list));
        //线程阻塞,等待所有任务完成
        pool.awaitTermination(10, TimeUnit.SECONDS);
        // 关闭线程池
        pool.shutdown();
    }

}

我又在网上找了一个有累加结果的示例,如下所示:

扫描二维码关注公众号,回复: 3691188 查看本文章

//继承RecursiveTask来实现”可分解”的任务

class CalTask extends RecursiveTask<Integer>
{
    // 每个“小任务”只最多只累加20个数
    private static final int THRESHOLD = 20;
    private int arr[];
    private int start;
    private int end;
    // 累加从start到end的数组元素
    public CalTask(int[] arr , int start, int end)
    {
        this.arr = arr;
        this.start = start;
        this.end = end;
    }
    @Override
    protected Integer compute()
    {
        int sum = 0;
        // 当end与start之间的差小于THRESHOLD时,开始进行实际累加
        if(end - start < THRESHOLD)
        {
            for (int i = start ; i < end ; i++ )
            {
                sum += arr[i];
            }
            return sum;
        }
        else
        {
            // 如果当end与start之间的差大于THRESHOLD时,即要打印的数超过20个
            // 将大任务分解成两个小任务。
            int middle = (start + end) /2;
            CalTask left = new CalTask(arr , start, middle);
            CalTask right = new CalTask(arr , middle, end);
            // 并行执行两个“小任务”
            left.fork();
            right.fork();
            // 把两个“小任务”累加的结果合并起来
            return left.join() + right.join();
        }
    }
}
public class Sum
{
    public static void main(String[] args)
        throws Exception
    {
        int[] arr = new int[100];
        Random rand = new Random();
        int total = 0;
        // 初始化100个数字元素
        for (int i = 0 , len = arr.length; i < len ; i++ )
        {
            int tmp = rand.nextInt(20);
            // 对数组元素赋值,并将数组元素的值添加到total总和中。
            total += (arr[i] = tmp);
        }
        System.out.println(total);

        ForkJoinPool pool = new ForkJoinPool();
        // 提交可分解的CalTask任务
        Future<Integer> future = pool.submit(new CalTask(arr , 0 , arr.length));
        System.out.println(future.get());
        // 关闭线程池
        pool.shutdown();
    }
}

我现在并不知道ForkJoinPool具体的实现思路及它是怎么执行我拆分的小任务,但它内部讲究的是线程之间的整体协作。当内部线程A空闲时,它会拿线程B的任务去执行。线程B也会执行自己的任务,只不过两个线程是从任务队列的两端执行,尽量减少冲突。

只有不断的学习,才会有提高,才会变得更加强大。希望过段时间我会发现更好的实现方式。

猜你喜欢

转载自blog.csdn.net/cdw8131197/article/details/62893209