深入理解并发(一)

一 为什么需要并发?
或许我们想到的第一个理由是:使程序更快的执行,确实,对于多处理器的机器来说,利用并发将每个任务分配到多个CPU上,能使程序更快的执行。
但在单处理器机器上运行并发程序，由于上下文切换（CPU控制权由运行任务转移到另外一个就绪任务时所发生的事件）的代价，开销甚至比顺序执行还要大，那是不是说，并发对于单处理器来说就没有作用了呢？
其实不然，因为考虑到一种情况“阻塞”,如果没有并发,那么阻塞可能会导致整个程序停止了,对于Android来说,更是会出现ANR.但是引入并发后,当一个任务阻塞了,程序中其他任务还可以继续执行.

二 JAVA中并发是如何实现的?
JAVA引入了线程机制,即是在由执行程序表示的单一进程中创建任务.而且JAVA的线程机制是抢占式的,即通过线程调度器周期性地中断线程,将上下文切换到另一个线程,为每个线程都提供时间片,使得每个线程都会分配到数量合理的时间去驱动它的任务.通过这种方式,程序中每个子任务都由执行线程来驱动.

三 JAVA中定义任务:
1,通过实现Runnable接口并编写run()方法.然后将Runnable对象提交给Thread构造器,然后调用Thread类的start()方法,并可以启动任务.(注意,虽然也可以直接调用Runnable的run()方法,但如果通过这种方式,则相对于调用了一个方法而已,并没有涉及到多线程.)

Runnable run = new Runnable(){
    public void run(){
    }
}
new Thread(run).start();

2,直接通过继承Thread类,然后重写Thread类中的run()方法.

class run extends Thread{
    public void run(){
    }
}

四 为什么需要线程池?
如果用Thread创建的线程数量很多,并且每个线程执行任务的时间很短,这样频繁创建就会大大降低系统的效率,因为频繁创建线程和销毁线程需要开销.
若引入了线程池,则可以重用存在的线程,减少对象的创建,销毁所花费的开销.并且人为控制最大并发数量,避免过多竞争.
Java通过Executors提供四种线程池，分别为：

1. newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

2. newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

3. newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

4. newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
   若这几种线程池仍不能满足,可以直接使用ThreadPoolExecutors类,因为newFixedThreadPool,newSingleThreadExecutor以及newCachedThreadPool的实现都是采用了ThreadPoolExecutors类,只是配置好参数而已,接下来看一下它们的源码实现:

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                          new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                          new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                            new SynchronousQueue<Runnable>());
}

从它们的实现可以看到,它们都是实现了:

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), defaultHandler);
    }

其中
? corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
? maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
? keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止(即run()方法返回时,才叫结束)。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
? unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒
?workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;

因此,若Executors所提供的线程池不能满足要求,可以自己根据需要去构造ThreadPoolExecutor.

关于ThreadPoolExecutor类更详细的解析请看:
http://www.cnblogs.com/dolphin0520/p/3932921.html