利用java的多线程编程可以大大的提高系统的并发运行效率，线程越多并发执行的任务就越多，但是并不意味着效率会一直提高，相反会得到适得其反的效果。
java中的多线程编程一共有三种方法：
继承Thread类
继承Runnable接口
使用线程池Executor
下面简单的介绍一些Executor的使用
一、话不多说先上代码：
创建一个线程数为3的线程池，模拟十个任务让线程池调度线程去完成。
package executorExample; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; public class Threads{
private static final int nThreads = 3;
private int i;
public void Thread(){
//实现ExecutorService接口创建 线程数为三个的线程池
ExecutorService executorService = Executors.newFixedThreadPool(nThreads);
for (i = 0; i < 10; i++) {
//在匿名内部类中变量index还在必须把index声明成final类型
final int index = i;
executorService.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
String threadName = Thread.currentThread().getName();//获取当前线程的名字
System.out.println(threadName+"正在执行任务:"+index);
}
});
}
}
public static void main(String[] args){
Threads thread = new Threads();
thread.Thread();
}
}
接下来解释一下这段代码。在这段代码当中用到的关键词有ExcutorService,Executors,newFixedThreadPool和execute方法，还有一个最重要的Executor，现在来解释一下他们之间的关系
1、Executors
首先我们先看一下Executors的源码
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
｝
public static ExecutorService newWorkStealingPool(int parallelism) {
return new ForkJoinPool
(parallelism,
ForkJoinPool.defaultForkJoinWorkerThreadFactory,
null, true);
}
public static ExecutorService newWorkStealingPool() {
return new ForkJoinPool
(Runtime.getRuntime().availableProcessors(),
ForkJoinPool.defaultForkJoinWorkerThreadFactory,
null, true);
}
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory);
}
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory));
}
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
threadFactory);
}
里面有四种都是ExecutorService类型的线程池，也就是说，我们在创建线程池的时候可以有四种选择，newCachedThreadPool，newFixedThreadPool，newSingleThreadExecutor，newWorkStealingPool。其中最常用的就是newCatchedThreadPool和newFixedThreadPool,可以看到每个线程池的参数队列是不同的，LinkedBlockingQueue<Runnable>()属于无边界队列，
(1)newFixedThreadPool
是一个固定线程数的线程池，当线程池里线程满了之后，下载任务就会被阻塞到等待下载队列里面等待下载。而LinkedBlockingQueue<Runnable>()无限扩容的FIFO规则的队列，我们在编程的时候一般用它比较多。
(2)newCatchedThreadPool
是一个可缓存线程池，如果线程池里的线程数超过了处理需要，则线程池可以灵活的回收空闲的线程，
别的线程池就先不介绍了
2、ExecutorService
public interface ExecutorService extends Executor {
在接口ExecutorService的源码中我们可以看到继承了Executor类，并且在ExecutorService方法中实现了
void shutdown();
invokeAll();
submit();
等等的方法。
3、Executor
public interface Executor {
void execute(Runnable command);
}
在接口Executor中只有一个execute()方法,这是用来将任务提交给线程的。
到这里就明白了他们之间的关系，这样可以帮助我们更好的利用线程池去提高我们的代码效率。
写的不是很完善，如果有大神，希望多多指教，写这个东西也是为了自己能够更熟练的使用线程池。