java多线程计算素数

Java并发是个很常用的知识点。面试基本上是必问，工作中也常用。

并发的风险：

1，程序饥饿，比如一个程序运行的时候要得到操作员的确认，但是操作员吃饭去了，这个程序将一直处于等待状态。

2，死锁：相互等待对方所占有的资源。

3，资源竞争：两个程序竞争相同的资源。

举个栗子：计算一个范围内素数的个数，首先是用常用的顺序计算，然后用多线程进行计算。比较两者的执行效率。下面是一个工具类，顺序计算和多线程计算都要用到。

package com.sunyard.demo.concurrency;

/**
 * 此类作为工具类
 */
public abstract class AbstractPrimeFinder {
    /**
     * 判断一个数是否为素数
     * @param number
     * @return
     */
    public boolean isPrime(final int number){
        if(number <= 1) return false;
        for(int i=2;i<=Math.sqrt(number);i++)
            if(number % i==0) return false;
            return true;
    }

    /**
     * 计算一个区间内的素数的个数
     * @param lower
     * @param upper
     * @return
     */
    public int countPrimesInRange(final int lower,final int upper){
        int total=0;
        for (int i=lower;i<=upper;i++)
            if(isPrime(i)) total++;
        return total;
    }

    /**
     * 统计程序计算素数所花费的时间
     * @param number
     */
    public void timeAndCompute(final int number){
        final long start = System.nanoTime();
        final long numberOfPrimes=countPrimes(number);
        final long end = System.nanoTime();
        System.out.printf("Number of primes under %d is %d\n",number,numberOfPrimes);
        System.out.println("Time (seconds) taken is:"+(end-start)/1.0e9);
    }
    public abstract int countPrimes(final int number);
}

单线程的情况如下：

package com.sunyard.demo.concurrency;

/**
 * 启动类
 */
public class SequentialPrimeFinder extends AbstractPrimeFinder {
    /**
     * 实现父类中的方法
     * @param number
     * @return
     */
    @Override
    public int countPrimes(final int number) {
        return countPrimesInRange(1,number);
    }
    /**
     * 程序主方法
     * @param args
     */
    public static void main(String[] args){
        //计算的区间为1到10000000
        new SequentialPrimeFinder().timeAndCompute(10000000);
    }
}

多线程如下：

public class ConcurrentPrimeFinder extends AbstractPrimeFinder {
    private final int poolSize;//创建线程的个数
    private final int numberOfParts;//任务的份数

    /**
     * 构造方法初始化线程的个数和任务的划分
     * @param poolSize
     * @param numberOfParts
     */
    public ConcurrentPrimeFinder(final int poolSize, final int numberOfParts) {
        this.poolSize = poolSize;
        this.numberOfParts = numberOfParts;
    }

    @Override
    public int countPrimes(final int number) {
        int count=0;//统计各区间的素数个数
        try {
            final List<Callable<Integer>> partitions=new ArrayList<Callable<Integer>>();
            final int chunksPerPartion=number /numberOfParts;
            for(int i=0; i<numberOfParts;i++){
                final int lower=(i*chunksPerPartion)+1;
                final int upper=(i==numberOfParts-1)? number:lower+chunksPerPartion-1;
                partitions.add(new Callable<Integer>() {
                    @Override
                    public Integer call() {
                        return countPrimesInRange(lower,upper);
                    }
                });
            }
            final ExecutorService executorPool= Executors.newFixedThreadPool(poolSize);//在线程池中创建线程
            final List<Future<Integer>> resultFromParts=executorPool.invokeAll(partitions,10000,TimeUnit.SECONDS);
            executorPool.shutdown();//执行完成之后关闭线程池
            for(final Future<Integer> result:resultFromParts)//统计各任务的素数个数
                count +=result.get();
        }catch (Exception ex){
            throw new RuntimeException(ex);
        }
        return count;
    }
    public static void main(String[] args){
        new ConcurrentPrimeFinder(4,4).timeAndCompute(10000000);
    }
}