线程池初识（一）

1.线程池简述

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

2.线程池思想概述

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。我们通过一张图来了解线程池的工作原理：

合理利用线程池能够带来三个好处：

1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内
   存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

3.线程池的使用

Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService
要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在 java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

3.1单线程线程池

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

//效果与定长线程池 创建时传入数值1 效果一致.
/**
 * 单线程线程池.
 * 执行流程:
 * 1. 判断线程池 的那个线程 是否空闲
 * 2. 空闲则使用
 * 4. 不空闲,则等待 池中的单个线程空闲后 使用
 */

public class SingleThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService service= Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了");
            }
        });
        //关闭线程池
        service.shutdown();
    }
}

实验结果如下：

pool-1-thread-1执行了
pool-1-thread-1执行了
pool-1-thread-1执行了

3.2定长线程池

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

/**
 * 定长线程池.
 * (长度是指定的数值)
 * 执行流程:
 3. 单线程线程池
 4. 周期性任务定长线程池
 * 1. 判断线程池是否存在空闲线程
 * 2. 存在则使用
 * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
 * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
 */
public class FixedThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService service= Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了");
            }
        });
        service.shutdown();
    }
}

测试结果如下：

pool-1-thread-2执行了
pool-1-thread-1执行了
pool-1-thread-2执行了
pool-1-thread-1执行了

3.3缓存线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 缓存线程池.
 * (长度无限制)
 * 执行流程:
 * 1. 判断线程池是否存在空闲线程
 * 2. 存在则使用
 * 3. 不存在,则创建线程 并放入线程池, 然后使用
 */

public class CachedThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException {
        //获取缓存线程池
        ExecutorService service= Executors.newCachedThreadPool();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"zhixinhsa");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"zhixinhsa");
            }
        });
   Thread.sleep(300);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"zhixinhsa");
            }
        });
   service.shutdown();
    }
}

测试结果如下：

pool-1-thread-1zhixinhsa
pool-1-thread-1zhixinhsa
pool-1-thread-1zhixinhsa

3.4周期性任务定长线程池

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 周期任务 定长线程池.
 * 执行流程:
 * 1. 判断线程池是否存在空闲线程
 * 2. 存在则使用
 * 3. 不存在
 * 空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
 * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
 *
 * 周期性任务执行时:
 * 定时执行, 当某个时机触发时, 自动执行某任务 .
 */
public class Demo {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        /**
         * 定时执行
         * 参数1. runnable类型的任务
         * 参数2. 时长数字
         * 参数3. 时长数字的单位
         */
        scheduledExecutorService.schedule(new Runnable() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"执行了");
    }
},5, TimeUnit.SECONDS);

        /**
         * 周期执行
         * 参数1. runnable类型的任务
         * 参数2. 时长数字(延迟执行的时长)
         * 参数3. 周期时长(每次执行的间隔时间)
         * 参数4. 时长数字的单位
         */
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"执行了sdds");
    }
},2,1,TimeUnit.SECONDS);
    }
}

测试结果如下：

pool-1-thread-1执行了sdds
pool-1-thread-1执行了sdds
pool-1-thread-1执行了sdds
pool-1-thread-2执行了
pool-1-thread-1执行了sdds
pool-1-thread-1执行了sdds
pool-1-thread-1执行了sdds
.....未完待续