JDK并发包（线程池）（2）

最新推荐文章于 2023-09-14 11:16:55 发布

蛇皮皮蛋

最新推荐文章于 2023-09-14 11:16:55 发布

阅读量4k

点赞数

分类专栏：多线程 Java 文章标签： Java 多线程 FrokJoinPool

本文链接：https://blog.csdn.net/qq_37598011/article/details/81515363

版权

Java 同时被 2 个专栏收录

41 篇文章 2 订阅

订阅专栏

多线程

15 篇文章 0 订阅

订阅专栏

在线程池中寻找堆栈

首先来看下这段代码

package thread.pool;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo {
	public static class DivTask implements Runnable{

		int a,b;
		public DivTask(int a,int b) {
			this.a=a;
			this.b=b;
		}
		
		@Override
		public void run() {
			double re=a/b;
			System.out.println(re);
		}
		
	}
	public static void main(String[] args) {
		ThreadPoolExecutor pool=new ThreadPoolExecutor(0, Integer.MAX_VALUE, 
				0, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
		
		for(int i=0;i<5;i++) {
			pool.submit(new DivTask(100,i));
		}
		
	}
	
}

讲道理啊，他会输出5次，可是实际情况是：

这组程序只有4组数据并且没有报任何错误信息。一种最简单的方法是将submit()改为execute()。或者使用Future。

但是这两种方法只能得到部分信息。并不能得到详细的行数。

为了能打印详细的堆栈信息所以重写了ThreadPoolExecutor类：

package thread.pool;

import java.util.concurrent.*;

/**
 * 自己扩展线程池获取异常位置 重写submit:可以拉取异常
 */
public class TraceThreadPoolExecutor extends ThreadPoolExecutor {

	// 初始化
	public TraceThreadPoolExecutor(int corePoolSize, int maxmumPoolSize, long keepAliveTime, TimeUnit unit,
			BlockingQueue<Runnable> workQueue) {
		super(corePoolSize, maxmumPoolSize, keepAliveTime, unit, workQueue);
	}

	// 执行方法
	@Override
	public void execute(Runnable task) {
		super.execute(wrap(task, clientTrace(), Thread.currentThread().getName()));
	}

	@Override
	public Future<?> submit(Runnable task) {
		return super.submit(wrap(task, clientTrace(), Thread.currentThread().getName()));
	}

	private Exception clientTrace() {
		// 扔出异常
		return new Exception("堆栈跟踪");
	}

	private Runnable wrap(final Runnable task, final Exception clientStack, String clientThreadName) {

		return new Runnable() {
			public void run() {

				try {
					task.run();
				} catch (Exception e) {
					clientStack.printStackTrace();
					throw e;
				}
			}
		};
	}

	public static class DivTask implements Runnable {

		int a, b;

		public DivTask(int a, int b) {
			this.a = a;
			this.b = b;
		}

		@Override
		public void run() {
			double re = a / b;
			System.out.println(re);
		}

	}

	public static void main(String[] args) {
		ThreadPoolExecutor pools = new TraceThreadPoolExecutor(0, Integer.MAX_VALUE, 0l, TimeUnit.SECONDS,
				new SynchronousQueue<Runnable>());
		// 错误堆栈中可以看到是在哪里提交的任务
		for (int i = 0; i < 5; i++) {
			pools.execute(new DivTask(100, i));
		}
	}
}

在重写的wrap()方法的第二个参数是一个异常，里面保存提交任务的线程堆栈信息，该方法将我们传入的Runnable任务进行了一层包装使其能处理异常信息。当任务发生异常时，这个异常会被打印。

Fork/Join框架

“分而治之”是非常有效地处理大量数据的方法。在Linux平台函数fork()用来创建子进程，使系统进程可以多一个执行分支。在Java中也沿用了类似的命名方式。

join()的含义是表示等待。也就是使用fork()后系统多了一个执行分支（线程），所以需要等待这个执行分支执行完毕才能得到最终结果，所以join表示等待。

在实际使用中如果毫无顾忌使用fork()开启线程进行处理，那么很有可能导致系统开启过多的线程而严重影响性能。所以在JDK中给出了一个ForkJoinPool线程池，它不会急着开启线程，而是提交给ForkJoinPool线程池进行处理以节省系统资源。

而由于线程的优化，提交的任务和线程的数量并不是一对一的关系。在大多数情况下，一个物理线程实际上需要处理多个逻辑任务。因此每个线程都拥有一个任务队列。当一个线程执行完自己的任务后会帮助其他线程执行任务，它会从底部开始拿数据，而当前线程会从顶部开始拿，这种机制有效的避免了数据竞争。

ForkJoinPool的一个重要接口：

public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task)

你可以向ForkJoinPool线程池提交一个ForkJoinTask任务（支持fork()分解以及join()等待的任务。）ForkJoinTask有两个重要的子类，RecursiveAction和RecusiveTask。他们分别表示没有返回值的任务和可以携带返回值得任务。

举个例子通过Fork/Join框架进行数列求和：

package thread.pool;

import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class CountTask extends RecursiveTask<Long> {
    private static final int THRESHOLD=1000;
    private long start;
    private long end;


    public CountTask(long start, long end) {
        super();
        this.start = start;
        this.end = end;
    }


    @Override
    protected Long compute() {
        long sum=0;
        boolean canCompute=(end - start)<THRESHOLD;
        if(canCompute){
            for (long i = start; i < end; i++) {
                sum+=i;
            }

        }else{
            long step=(end - start)/100;
            ArrayList<CountTask> sunTasks = new ArrayList<CountTask>();
            long pos=start;
            for (int i = 0; i <100; i++) {
                long lastOne=pos+step;
                if(lastOne>end){
                    lastOne=end;
                }
                CountTask sunTask=new CountTask(pos,lastOne);
                pos+=step+1;
                sunTasks.add(sunTask);
                sunTask.fork();
            }
            for (CountTask t : sunTasks) {
                sum+=t.join();
            }


        }

        return sum;
    }


    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ForkJoinPool forkJoinPool = new ForkJoinPool();

        for(int i=1;i<10000;i++) {
        	CountTask countTask = new CountTask(0,i);
        	
        	ForkJoinTask<Long> result = forkJoinPool.submit(countTask);
        	
        	Long res = result.get();
        	System.out.println(res);
        	
        }



    }

}

因为需要返回值所以这里用的是RecursiveTask作为任务模型。ForkJoinPool forkJoinPool = new ForkJoinPool();构建一个ForkJoinPool线程池，CountTask countTask = new CountTask(0,i);构造了了一个计算0~i求和的任务。然后通过ForkJoinTask<Long> result = forkJoinPool.submit(countTask);将任务提交。如果 boolean canCompute=(end - start)<THRESHOLD;为true表示小于1000则用for循环直接相加。否则将其分解，每次分解时简单的先将原有任务划分成100个等规模的小任务并使用fork()提交子任务，最通过循环那个列表join获取最后的值。