java 单线程池 java线程池实例项目

java线程池应用案例

• 一、线程池知识

• 二、线程池的创建
• 1、测试线程
• 2、普通测试案例
• 3、newSingleThreadExecutor
• 4、newFixedThreadPool
• 5、 newCachedThreadPool
• 6、newScheduledThreadPool（情况一）
• 7、newScheduledThreadPool（情况二）
• 7、newScheduledThreadPool（情况三）

---

一、线程池知识

根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

• 减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
• 可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因线程过多消耗内存，也避免了因线程过少，浪费系统资源。

二、线程池的创建

1、测试线程

public class MyThread extends Thread {

    private int i;

    public MyThread(int in) {
        this.i = in;
    }

    @Override
    public void run() {
        try {
            sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(currentThread().getName() + "正在打印：" + i);
    }
}

2、普通测试案例

void contextLoad6() {
        for (int i = 0; i < 10; i++) {
            MyThread myThread = new MyThread(i);
            myThread.run();
        }
    }

3、newSingleThreadExecutor

说明：初始化只有一个线程的线程池，内部使用LinkedBlockingQueue作为阻塞队列。
特点：相当于单线程串行执行所有任务如果该线程异常结束，会重新创建一个新的线程继续执行任务，唯一的线程可以保证所提交任务的顺序执行

void contextLoad7() {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            executorService.execute(new MyThread(i));
        }
        executorService.shutdown();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

4、newFixedThreadPool

说明：初始化一个指定线程数的线程池，其中corePoolSize == maxiPoolSize，使用LinkedBlockingQuene作为阻塞队列
特点：每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，即使当线程池没有可执行任务时，也不会释放线程。如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

void contextLoad8() {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new MyThread(i));
        }
        executorService.shutdown();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

5、 newCachedThreadPool

说明：初始化一个可以缓存线程的线程池，此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。线程池的线程数可达到Integer.MAX_VALUE，即2147483647，内部使用SynchronousQueue作为阻塞队列；
特点：在没有任务执行时，当线程的空闲时间超过keepAliveTime，默认为60s，会自动释放线程资源；当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；
因此，使用时要注意控制并发的任务数，防止因创建大量的线程导致而降低性能。

void contextLoad9() {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            executorService.execute(new MyThread(i));
        }
        executorService.shutdown();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

6、newScheduledThreadPool（情况一）

特定：初始化的线程池可以在指定的时间内周期性的执行所提交的任务，在实际的业务场景中可以使用该线程池定期的同步数据。
总结：除了newScheduledThreadPool的内部实现特殊一点之外，其它线程池内部都是基于ThreadPoolExecutor类（Executor的子类）实现的。

public class MyThread2 extends Thread {

    private int i;

    public MyThread2(int in) {
        this.i = in;
    }

    @Override
    public void run() {
        while (true) {
            try {
                //每两秒执行一次
                sleep(2000);
            } catch (InterruptedException E) {
                E.printStackTrace();
            }
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = new Date();
            System.out.println(currentThread().getName() + "打印编号：" + i + "======>" + sdf.format(date));//答应当前时间
        }
    }

}

void contextLoad10() {
        ScheduledThreadPoolExecutor atpe = new ScheduledThreadPoolExecutor(5);//设置线程个数
        for (int i = 0; i < 5; i++) {
            atpe.execute(new MyThread2(i));//普通的提交方式，只提交一次，执行结束，线程不会退出。
        }
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

7、newScheduledThreadPool（情况二）

程序正常结束，且线程3被重复利用，并没达到线程池的最大容量4。
我们可以这样认为，newScheduledThreadPool这线程池可以使只执行一遍的线程以一定速率循环执行，但是如果以execute方式提交线程则不会重复执行。

public class MyThread3 extends Thread {

    private int i;

    public MyThread3(int in) {
        this.i = in;
    }

    @Override
    public void run() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = new Date();
        System.out.println(currentThread().getName() + "打印编号：" + i + "======>" + sdf.format(date));//答应当前时间
    }
}

void contextLoad11() {
        ScheduledThreadPoolExecutor atpe = new ScheduledThreadPoolExecutor(4);//设置线程个数
        for (int i = 0; i < 5; i++) {
            atpe.execute(new MyThread3(i));//普通的提交方式，只提交一次，执行结束，线程不会退出。
        }
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

7、newScheduledThreadPool（情况三）

我们可以发现线程2实现了重复利用，虽然创建的线程是一次执行，但却实现了重复执行的效果，这就是该线程池最大的特点。

void contextLoad12() {
        ScheduledThreadPoolExecutor atpe = new ScheduledThreadPoolExecutor(4);//设置线程个数
        for (int i = 0; i < 5; i++) {
            //参数2：initialDelay表示首次执行任务的延迟时间，参数3：period表示每次执行任务的间隔时间，参数4：TimeUnit.MILLISECONDS执行的时间间隔数值单位
            atpe.scheduleAtFixedRate(new MyThread3(i),1000,2000, TimeUnit.MILLISECONDS);//以固定频率重复执行线程
        }
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }