本文主要通过一个获取某个区间内质数的例子来说明如何使用java进行多线程并发处理任务。
1. 需求:
获取某个区间内质数，同时任务在处理完成后，要返回任务执行时间。
分析：
需求中指明要在任务处理完成后，返回执行时间，所以要监听所有任务执行的状态。
高效处理：使用线程池，这里使用接口ExecutorService类；
监听任务状态：使用FutureTask类；
2. 新建一个Math类,并发处理核心类:
package hrt.executor;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ThreadPoolExecutor;
public class Math {
private static final int MAX_THREAD_COUNT = 10;
/**
* 获取区间中的质数
* @param start
* @param end
* @return
*/
public static List<Long> getPrimeNumbers(Long start, Long end) {
Long[] points = getPoints(start, end);
List<Long> primeNumbers = new ArrayList<Long>();
List<FutureTask<List<Long>>> futureTaskList = new ArrayList<FutureTask<List<Long>>>();
ExecutorService excutorService = Executors.newFixedThreadPool(MAX_THREAD_COUNT);
for (int i = 0; i < points.length - 1; i++) {
// FutureTask可以看成是一个可以加入线程池的job,用来执行具体的任务
FutureTask<List<Long>> futureTask = new FutureTask<List<Long>>(
new GetPrimeTask(points[i], points[i + 1] - 1));
futureTaskList.add(futureTask);
// executorService可以看成是一个线程池,调用submit方法提交Task任务
excutorService.submit(futureTask);
}
for (FutureTask<List<Long>> futureTask : futureTaskList) {
try {
// get方法获取job计算得到的结果,该方法只有在Task完成任务后才会有返回.
List<Long> partPrimeNumbers = futureTask.get();
primeNumbers.addAll(partPrimeNumbers);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
ThreadPoolExecutor tp = (ThreadPoolExecutor) excutorService;
System.out.println("池中最大的线程数据" + tp.getMaximumPoolSize() + ",当前池中线程数:" + tp.getPoolSize() + ",完成任务数:"
+ tp.getCompletedTaskCount());
return primeNumbers;
}
/**
* 判断是否是质数:只能被1和自身整除
*
* @param num
* @return
*/
public static boolean isPrimeNumber(Long num) {
for (Long i = 2L; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
/**
* 将数据拆分为多个数据区间
* @param start
* @param end
* @return
*/
private static Long[] getPoints(Long start, Long end) {
Long[] points = new Long[MAX_THREAD_COUNT];
for (int i = 0; i < MAX_THREAD_COUNT - 1; i++) {
points[i] = start + (end - start) / (MAX_THREAD_COUNT - 1) * i;
}
points[MAX_THREAD_COUNT - 1] = end + 1;
return points;
}
}
说明：
这个Math类中有两个重要的类，一个是ExecutorService，它可以认为是一个线程池；另外一个是FutureTask， 这个可以认为是可以加入线程池中的一个Job，用来执行具体的任务。
在上面的代码中，我们将每一个FutureTask对象保存起来，然后加入到线程池中并submit提交任务，最后遍历每一个FutureTask对象，通过该对象的get方法来获取这个job计算得到的结果，get方法只有在job完成任务后才会返回。
3. 新建GetPrimeTask类：
package hrt.executor;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
public class GetPrimeTask implements Callable<List<Long>> {
private Long start;
private Long end;
public GetPrimeTask(Long start, Long end) {
this.start = start;
this.end = end;
}
public List<Long> call() throws Exception {
List<Long> primeNumberList = new ArrayList<Long>();
for (Long i = start; i <= end; i++) {
//判断是否是质数,是的话插入集合中
if (Math.isPrimeNumber(i)) {
primeNumberList.add(i);
}
}
return primeNumberList;
}
}
说明：必须要实现Callable接口。
4. 测试程序入口:
package hrt.executor;
import java.sql.Time;
import java.util.Calendar;
import java.util.List;
/**
* 主程序入口
*
*/
public class App
{
public static void main( String[] args )
{
System.out.println("start");
Long startTime = getCurTime();
List<Long> primeNumberList = Math.getPrimeNumbers(200000L, 300000L);
for (Long primeNumber : primeNumberList) {
System.out.println("" + primeNumber);
}
Long endTime = getCurTime();
System.out.println("消耗时间:" + (endTime - startTime) + " ms");
}
private static Long getCurTime() {
Calendar c = Calendar.getInstance();
return c.getTimeInMillis();
}
}
5. 追加说明:
在Math类中使用的ExecutorService类其实就是一个线程池中线程数固定的线程池，这里固定的线程数有常量 MAX_THREAD_COUNT=10 进行设置。
（1）创建线程池时，初始线程池中线程数为0，当提交的任务数小于线程数时，线程池中的线程数会等于任务数；当提交的任务数大于固定线程数时，多出的任务会处在等待中，当线程池中线程开始有空闲时，才会处理等待中的任务。
（2）对于固定线程数的线程池，当提交的任务处理完成后，线程池中空闲的线程还会一直存在不会中断。
任务执行完毕后，线程还在
