java笔记--使用线程池优化多线程编程

使用线程池优化多线程编程

认识线程池

在Java中，所有的对象都是需要通过new操作符来创建的，
如果创建大量短生命周期的对象，将会使得整个程序的性能非常的低下。
这种时候就需要用到了池的技术，比如数据库连接池，线程池等。

在java1.5之后，java自带了线程池，在util包下新增了concurrent包，
这个包主要作用就是介绍java线程和线程池如何使用的。

在包java.util.concurrent下的 Executors类中定义了Executor、ExecutorService、ScheduledExecutorService、
ThreadFactoryScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。

此类支持以下各种方法：
    a.创建并返回设置有常用配置字符串的 ExecutorService 的方法。
    b.创建并返回设置有常用配置字符串的 ScheduledExecutorService 的方法。
    c.创建并返回“包装的”ExecutorService 方法，它通过使特定于实现的方法不可访问来禁用重新配置。
    d.创建并返回 ThreadFactory 的方法，它可将新创建的线程设置为已知的状态。
    e.创建并返回非闭包形式的 Callable 的方法，这样可将其用于需要 Callable 的执行方法中。
   --如果朋友您想转载本文章请注明转载地址"http://www.cnblogs.com/XHJT/p/3897773.html "谢谢-- 
首先我们先来比较一下用线程池创建多个线程和用独立运行的方式创建多个线程的区别，
这里我们将通过比较两种方法占有内存和花费时间，来说明线程池的必要性和重要性。

代码实例：

package com.xhj.thread;

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

/**
 * 比较独立创建和线程池创建线程的优劣 比较因素--时间和占用内存
 *
 * @author XIEHEJUN
 *
 */
public class CompareThreadPool implements Runnable {
    private int id = 0;

    @Override
    public void run() {
        id++;

    }

    public static void main(String[] args) {
        /**
         * 独立创建1000个线程
         */
        {
            // 获取当前程序运行时对象
            Runtime run = Runtime.getRuntime();
            // 调用垃圾回收机制，以减少内存误差
            run.gc();
            // 获取当前JVM的空闲内存
            long freeMemory = run.freeMemory();
            // 系统当前时间
            long timePro = System.currentTimeMillis();
            // 独立创建并执行1000个线程
            for (int i = 0; i < 1000; i++) {
                new Thread(new CompareThreadPool()).start();
            }
            System.out.println("独立创建并执行1000个线程所需要占用的内存大小: "
                    + (freeMemory - run.freeMemory()));
            System.out.println("独立创建并运行1000个线程需要的时间为: "
                    + (System.currentTimeMillis() - timePro));
        }
        /**
         * 利用线程池创建1000个线程
         */
        {
            // 获取当前程序运行时对象
            Runtime run = Runtime.getRuntime();
            // 调用垃圾回收机制，以减少内存误差
            run.gc();
            // 获取当前JVM的空闲内存
            long freeMemory = run.freeMemory();
            // 系统当前时间
            long timePro = System.currentTimeMillis();
            ExecutorService service = Executors.newFixedThreadPool(2);
            // 线程池创建并执行1000个线程
            for (int i = 0; i < 1000; i++) {
                service.submit(new CompareThreadPool());
            }

            System.out.println("使用线程池创建1000个线程所需要占用的内存大小: "
                    + (freeMemory - run.freeMemory()));
            // 线程池使用完成，关闭线程池
            service.shutdown();
            System.out.println("使用线程池创建并运行1000个线程需要的时间为: "
                    + (System.currentTimeMillis() - timePro));

        }

    }

}

结果为：

结论--为什么要用线程池：    
    通过上面这个例子，我们知道使用线程池可以大大的提高系统的性能，提高程序任务的执行效率，
    节约了系统的内存空间。在线程池中，每一个工作线程都可以被重复利用，可执行多个任务，
    减少了创建和销毁线程的次数。能够根据系统的承受能力，调整其线程数目，以便使系统达到运行的最佳效果。

线程池原理：
    一个线程池中有多个处于可运行状态的线程，当向线程池中添加Runnable或Callable接口对象时，
    就会有一个线程来执行run()方法或call()方法。如果方法执行完毕，则该线程并不终止，
    而是继续在池中处于可运行状态，以运行新的任务。

了解线程池（java中创建线程池的几种常用静态方法）

在java中，线程池的顶级接口是util.concurrent包下的Executors工具类，在这个类里，定义了很多操作线程池的方法。
其中最常用的线程池有：
1.创建单线程的线程池：
    newSingleThreadExecutor()，创建一个只有一个线程的线程池，此单线程按照任务的提交顺序执行所有的任务，
    若遇到异常中断，线程池则会重新建立一个单线程来替代其完成后续工作。
    
    代码实例：

    /**
     * 创建一个单线程的线程池
      *
     * @return
     */
    public ExecutorService SingleThreadPool() {
        ExecutorService singlePool = Executors.newSingleThreadExecutor();
        return singlePool;
    }

2.创建一个可缓存的线程池:
    newCachedThreadPool()，创建一个不限制大小，且只能的线程池，他会根据任务量的多少来开辟和减少内存空间，
    但是线程池中线程的大小依赖于系统的性能或者JVM的容量
    
    代码实例：

   /**
     * 创建一个可缓存线程池
      *
     * @return
     */
    public ExecutorService CachedThreadPool() {
        ExecutorService cachedPool = Executors.newCachedThreadPool();
        return cachedPool;
    }

3.创建一个大小固定的线程池：
    newFixedThreadPool()，创建一个固定大小的线程池，任务提交则建立线程，直到线程大小达到线程池允许最大值，
    若某个线程结束，线程池则补充一个新的线程。

代码实例：

   /**
     * 创建一个大小固定的线程池
      *
     * @return
     */
    public ExecutorService FixedThreadPool() {
        ExecutorService fixedPool = Executors.newFixedThreadPool(2);
        return fixedPool;
    }

4.创建一个可定时、周期性执行的线程池
    newScheduledThreadPool()，创建一个可定时、周期性执行的线程池，此线程池没有大小限制，
    实现周期性任务调度。

代码实例：

ScheduledThreadPoolExecutor scheduledPool = new ScheduledThreadPoolExecutor(1);

为了便于大家理解和对比其不同之处，下面将把这几个常用线程池整合到一个程序当中，

代码实例：

package com.xhj.thread;

import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 几个常用线程池的理解与运用
 *
 * @author XIEHEJUN
 *
 */
public class CreateThreadPools extends Thread {

    @Override
    public void run() {
        System.out.println("系统时间 ： " + System.currentTimeMillis() + " 线程： "
                + Thread.currentThread().getName() + "正在执行！！");

    }

    /**
     * 创建一个单线程的线程池
     *
     * @return
     */
    public ExecutorService SingleThreadPool() {
        ExecutorService singlePool = Executors.newSingleThreadExecutor();
        return singlePool;
    }

    /**
     * 创建一个大小固定的线程池
     *
     * @return
     */
    public ExecutorService FixedThreadPool() {
        ExecutorService fixedPool = Executors.newFixedThreadPool(3);
        return fixedPool;
    }

    /**
     * 创建一个可缓存线程池
     *
     * @return
     */
    public ExecutorService CachedThreadPool() {
        ExecutorService cachedPool = Executors.newCachedThreadPool();
        return cachedPool;
    }

    /**
     * 将创建好的线程放入线程池，并执行
     *
     * @param pool
     */
    public void service(ExecutorService pool) {
        // 创建线程
        Thread thread1 = new CreateThreadPools();
        Thread thread2 = new CreateThreadPools();
        Thread thread3 = new CreateThreadPools();
        Thread thread4 = new CreateThreadPools();
        Thread thread5 = new CreateThreadPools();
        // 线程入线程池，并执行
        pool.execute(thread1);
        pool.execute(thread2);
        pool.execute(thread3);
        pool.execute(thread4);
        pool.execute(thread5);
        // 关闭线程池
        pool.shutdown();
    }

    /**
     * 创建一个大小无限制的线程池，可用与定时和周期性服务
     */
    public void scheduledThreadPool() {
        ScheduledThreadPoolExecutor scheduledPool = new ScheduledThreadPoolExecutor(1);

        scheduledPool.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                System.out.println("=======" + System.currentTimeMillis()
                        + "=========");
            }
        }, 1000, 5000, TimeUnit.MILLISECONDS);

        scheduledPool.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                System.out.println(System.nanoTime());

            }
        }, 1000, 2000, TimeUnit.MILLISECONDS);

    }

    public static void main(String[] args) {
        CreateThreadPools creatThreadPool = new CreateThreadPools();
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请选择创建线程池：1.单线程线程池；2.可缓存线程池；3.固定大小线程池；4可定时周期性执行线程池");
            int i = sc.nextInt();

            switch (i) {
            case 1:
                System.out.println("-----调用单线程的线程池-----");
                // 调用单线程的线程池
                creatThreadPool.service(creatThreadPool.SingleThreadPool());
                break;
            case 2:
                System.out.println("-----调用可缓存线程的线程池-----");
                // 调用可缓存线程的线程池
                creatThreadPool.service(creatThreadPool.CachedThreadPool());
                break;
            case 3:
                System.out.println("-----调用固定大小线程的线程池-----");
                // 调用固定大小线程的线程池
                creatThreadPool.service(creatThreadPool.FixedThreadPool());
                break;
            case 4:
                System.out.println("-----调用大小无限制可定时和周期性执行的线程池-----");
                // 调用固定大小线程的线程池
                creatThreadPool.scheduledThreadPool();
                break;
            }
        }
    }
}

注：当线程池任务结束之后，一定要记得将线程池关闭，执行shutdown()方法。