java 下计算质数的多线程跟单线程执行代码分析

 

public abstract class AbstractPrimeFinder {
	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;
	}

	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;
	}

	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);
}

public class SequentialPrimeFinder extends AbstractPrimeFinder {
	public int countPrimes(final int number) {
		return countPrimesInRange(1, number);
	}

	public static void main(final String[] args) {
		new SequentialPrimeFinder().timeAndCompute(10000000);
	}
}

在我的ubutun下双核cpu的输出

单线程下的执行结果

 

Number of primes under 10000000 is 664579
Time (seconds) taken is 7.518444261

 

多线程下

 

package com.mime;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class ConcurrentPrimeFinder extends AbstractPrimeFinder {
	private final int poolSize;
	private final int numberOfParts;

	public ConcurrentPrimeFinder(final int thePoolSize,
			final int theNumberOfParts) {
		poolSize = thePoolSize;
		numberOfParts = theNumberOfParts;
	}

	public int countPrimes(final int number) {
		int count = 0;
		try {
			final List<Callable<Integer>> partitions = new ArrayList<Callable<Integer>>();
			final int chunksPerPartition = number / numberOfParts;
			for (int i = 0; i < numberOfParts; i++) {
				final int lower = (i * chunksPerPartition) + 1;
				final int upper = (i == numberOfParts - 1) ? number : lower
						+ chunksPerPartition - 1;
				partitions.add(new Callable<Integer>() {
					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(final String[] args) {
			new ConcurrentPrimeFinder(4,100).timeAndCompute(10000000);
	}

}

 输出

 

Number of primes under 10000000 is 664579
Time (seconds) taken is 3.825282456

可以根据cpu个数和调整分区树来调优这个线程数来达到最有效果。