Java并发编程从入门到精通

1、什么是线程池（为什么使用线程池）：
2、Executor框架介绍：
  Java 5中引入的，其内部使用了线程池机制，在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭（使用该框架来创建线程池），可以简化并发编程的操作；
  Executor框架包括：线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等；
  ExecutorService接口继承自Executor接口，提供了更丰富的实现多线程的方法，一般用该接口来实现和管理多线程；
  ExecutorService的生命周期包括三种状态：运行、关闭、终止；创建后便进入运行状态；当调用了shutdown()方法时，便进入关闭状态，此时意味着ExecutorService不再接受新的任务，但它还在执行已经提交了的任务；当所有已经提交了的任务执行完后，便到达终止状态；如果不调用shutdown()方法，ExecutorService会一直处在运行状态，不断接收新的任务，执行新的任务，服务器端一般不需要关闭它，保持一直运行即可；
  更详细描述看：http://blog.csdn.net/ns_code/article/details/17465497

/**
 * Executor执行Runnable任务
 */
package thread05;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorsTest01
{
    public static void main(String[] args)
    {
        // ExecutorService executorService = Executors.newCachedThreadPool();
        // ExecutorService executorService = Executors.newFixedThreadPool(4);
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        
        // 创建5个任务并执行
        for(int i=0;i<5;i++)
        {
            executorService.execute(new RunnableTest2());
        }
        
        // 启动一次顺序关闭，执行以前提交的任务，但不接受新任务
        executorService.shutdown();
    }
}

class RunnableTest2 implements Runnable
{
    // 具体的业务逻辑；一旦RunnableTest2实例对象传给ExecutorService的execute方法， 则该方法（任务）自动在一个线程上执行
    @Override
    public void run()
    {
        System.out.println(Thread.currentThread().getName() + "线程被调用了");
    }
    
}

/**
 * Executor执行Callable任务
 */
package thread05;

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

public class ExecutorsTest02
{
    public static void main(String[] args)
    {
        ExecutorService executorService = Executors.newCachedThreadPool();
        List<Future<String>> futureList = new ArrayList<Future<String>>();
        
        // 创建10个任务并执行
        for(int i=0;i<10;i++)
        {
            // 使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
            Future<String> future = executorService.submit(new CallableTest2(i + ""));
            // 将任务执行结果存储到List中
            futureList.add(future);
        }
        
        // 遍历任务的结果 
        for(Future<String> f : futureList)
        {
            try
            {
                // Future返回如果没有完成，则一直循环等待，直到Future返回完成
                while(!f.isDone());
                // 打印各个线程（任务）执行的结果 
                System.out.println(f.get());
            }
            catch (InterruptedException | ExecutionException e)
            {
                e.printStackTrace();
            }
            finally
            {
                // 启动一次顺序关闭，执行以前提交的任务，但不接受新任务
                executorService.shutdown();
            }
        }
        
    }
}

class CallableTest2 implements Callable<String>
{
    private String id;
    
    public CallableTest2(String id)
    {
        this.id = id;
    }

    // 具体的业务逻辑；一旦CallableTest2实例对象传给ExecutorService的submit方法， 则该方法（任务）自动在一个线程上执行
    @Override
    public String call() throws Exception
    {
        System.out.println("call()方法被自动调用，当前线程名称" + Thread.currentThread().getName());
        return "call()方法被自动调用，任务的返回值：任务id：" + id + "，执行任务的线程名称：" + Thread.currentThread().getName();
    }
    
}

3、三种生成常用线程池的静态工厂方法（三种自带的线程池）：
  newSingleThreadExecutor（SingleThreadExecutor）；
  newCachedThreadPool（CachedThreadPool）；
  newFixedThreadPool（FixedThreadPool）；
4、newSingleThreadExecutor的使用：
  创建一个单线程的线程池，这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务；如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它；此线程池保证所有任务的执行顺序按照任务的提交顺序执行；
  适用场景：适用于需要保证顺序地执行各个任务；并且在任意时间点，不会有多个线程是活动的应用场景；

/**
 * newSingleThreadExecutor的使用
 */
package thread05;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewSingleThreadExecutorTest01
{
    public static void main(String[] args)
    {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        
        for(int i=0;i<5;i++)
        {
            final int no = i;
            
            // 生成一条任务
            Runnable runnable = new Runnable()
            {
                @Override
                public void run()
                {
                    try
                    {
                        System.out.println("into:" + no);
                        Thread.sleep(1000);
                        System.out.println("end:" + no);
                    } 
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            };
            
            // 将任务放到线程池中进行执行
            executorService.execute(runnable);
        }
        
        // 所有任务执行完毕之后，关闭线程池
        executorService.shutdown();
        
        System.out.println("Thread Main End!");
    }
}

5、newCachedThreadPool的使用：
  创建一个缓存池大小可根据需要伸缩的线程池，但是在以前构造的线程可用时可重用它们；对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能；调用execute将重用以前构造的线程（如果线程可用）；如果现有线程没有可用的，则创建一个新线程并添加到池中；终止并从缓存中移除那些已有60s未被使用的线程；因此，长时间保持空闲的线程池不会使用任何资源；
  适用场景：是大小无界的线程池，适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器；

/**
 * newCachedThreadPool的使用
 */
package thread05;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewCachedThreadPoolTest01
{
    public static void main(String[] args)
    {
        ExecutorService executorService = Executors.newCachedThreadPool();
        
        for(int i=0;i<10;i++)
        {
            final int no = i;
            
            Runnable runnable = new Runnable()
            {
                @Override
                public void run()
                {
                    try
                    {
                        System.out.println("into:" + no);
                        Thread.sleep(1000L);
                        System.out.println("end:" + no);
                    } 
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            };
            
            executorService.execute(runnable);
        }
        
        executorService.shutdown();
        
        System.out.println("Thread Main End!");
    }
}

6、newFixedThreadPool的使用：
  创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程；在任意点，在大多数nThreads线程会处于处理任务的活动状态；如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待；如果在关闭前的执行期间而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）；在某个线程被显式地关闭之前，池中的线程将一直存在；
  适用场景：适用于为了满足资源管理的需求，而需要限制当前线程数量的应用场景；适用于负载比较重的服务器；

/**
 * newFixedThreadPool的使用
 */
package thread05;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewFixedThreadPool
{
    public static void main(String[] args)
    {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        for(int i=0;i<20;i++)
        {
            final int no = i;
            
            Runnable runnable = new Runnable()
            {
                @Override
                public void run()
                {
                    try
                    {
                        System.out.println("into:" + no);
                        Thread.sleep(1000L);
                        System.out.println("end:" + no);
                    } 
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            };
            
            executorService.execute(runnable);
        }
        
        executorService.shutdown();
        
        System.out.println("Thread Main End!");
    }
}

7、线程池的好处；
7.1、合理利用线程池能够带来4个好处：
（1）、降低资源消耗：通过重复利用已创建的线程，降低线程创建和销毁造成的消耗；
（2）、提高响应速度：当任务到达时，任务可以不需要等待线程创建就能立即执行；
（3）、提高线程的可管理性：线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控；
（4）、防止服务器过载，形成内存溢出，或者CPU耗尽；
7.2、线程池技术提高服务器程序的性能：
多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力；但如果对多线程应用不当，会增加对单个任务的处理时间；
7.3、线程池的应用范围：
（1）、需要大量的线程来完成任务，且完成任务的时间比较短：Web服务器完成网页请求这样的任务，使用线程池技术是非常合适的；因为单个任务小，而任务数量巨大；
8、线程池的工作机制及其原理：
9、自定义线程池和ExecutorService：

/**
 * 自定义线程池
 */
package thread05;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest01
{
    public static void main(String[] args)
    {
        // 创建等待队列 
        BlockingQueue<Runnable> bq = new ArrayBlockingQueue<Runnable>(20);
        // 创建线程池，池中保存的线程数为3，允许的最大线程数为5  
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 50, TimeUnit.MILLISECONDS,bq);
        
        // 创建七个任务
        Runnable r1 = new RunnableTest3();
        Runnable r2 = new RunnableTest3();
        Runnable r3 = new RunnableTest3();
        Runnable r4 = new RunnableTest3();
        Runnable r5 = new RunnableTest3();
        Runnable r6 = new RunnableTest3();
        Runnable r7 = new RunnableTest3();
        
        // 每个任务会在一个线程上执行
        pool.execute(r1);
        pool.execute(r2);
        pool.execute(r3);
        pool.execute(r4);
        pool.execute(r5);
        pool.execute(r6);
        pool.execute(r7);
        
        // 关闭线程池 
        pool.shutdown();
    }
}

class RunnableTest3 implements Runnable
{
    @Override
    public void run()
    {
        System.out.println(Thread.currentThread().getName() + "正在执行...");
        
        try
        {
            Thread.sleep(1000);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    
}

10、线程池在工作中的错误使用：
（1）、分不清线程池是单例还是多对象：线程池一定要在合理的单例模式下才有效；就是说不要多次创建线程池；
（2）、线程池数量设置很大，请求过载：
（3）、注意死锁问题：