JAVA并发包与线程池

并发工具包-Concurrent

JDK1.5以后为我们专门提供了一个并发工具包java.util.concurrent。
java.util.concurrent 包含许多线程安全、测试良好、高性能的并发构建块。创建 concurrent 的目的就是要实现 Collection 框架对数据结构所执行的并发操作。通过提供一组可靠的、高性能并发构建块，开发人员可以提高并发类的线程安全、可伸缩性、性能、可读性和可靠性，
并发是伴随着多核处理器的诞生而产生的，为了充分利用硬件资源，诞生了多线程技术。但是多线程又存在资源竞争的问题，引发了同步和互斥的问题，JDK1.5推出的java.util.concurrent(并发工具包）来解决这些问题。

new Thread的弊端

new Thread()新建对象，性能差
线程缺乏统一管理，可能无限制的新建线程，相互竞争，严重时会占用过多系统资源导致死机或OOM

ThreadPool - 线程池

重用存在的线程，减少对象对象、消亡的开销
线程总数可控，提高资源的利用率
避免过多资源竞争，避免阻塞
提供额外功能，定时执行、定期执行、监控等。

线程池的种类

在java.util.concurrent中，提供了工具类Executors（调
度器）对象来创建线程池，可创建的线程池有四种：

1. CachedThreadPool - 可缓存线程池
2. FixedThreadPool - 定长线程池
3. SingleThreadExecutor - 单线程池
4. ScheduledThreadPool - 调度线程池

CachedThreadPool

package com.caiweiwei.lianxi.controller;

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

public class ThreadPoolSample1 {
    public static void main(String[] args) {
        ExecutorService threadPool= Executors.newCachedThreadPool();//创建一个可缓存线程池
        //可缓存线程池的特点是，无限大，如果线程池中没有可用的线程则创建，有空闲线程则利用起来
        for (int i=0;i<=100;i++){
            int index=i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+":"+index);
                }
            });
        }
        try{
            Thread.sleep(1000);//主线程足够的运行时间
        }catch (Exception e){
            e.printStackTrace();
        }
        //shutdown() 代表关闭线程池（等待所有线程完成）
        //shutdownNow() 代表立即终止线程池的运行，不等待线程,不推荐使用
        threadPool.shutdown();
    }
}

FixedThreadPool

package com.caiweiwei.lianxi.controller;

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

public class ThreadPoolSample2 {
    public static void main(String[] args) {
        //ExecutorService用于管理线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //创建一个可创建一个定长线程池
        //定长线程池的特点是固定线程总数，空间线程用于执行任务，如果线程都在使用后续任务则处于等待状态，在线程池中的线程
        //如果任务处于等待的状态，备选的等待算法默认为FIFO（先进先出) LIFO(后进先出)
        //执行任务后再执行后续的任务。
        for (int i = 0; i < 1000; i++) {
            int index = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+":"+index);
                }
            });
        }
        try {
            Thread.sleep(1000);
        }catch (Exception e){
            e.printStackTrace();
        }
        //shutdown() 代表关闭线程池（等待所有线程完成）
        //shutdownNow() 代表立即终止线程池的运行，不等待线程,不推荐使用
        executorService.shutdown();
    }
}

SingleThreadExecutor

package com.caiweiwei.lianxi.controller;

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

public class ThreadPoolSample3 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单线程线程池
        for (int i = 0; i < 1000; i++) {
            int index = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + index);
                }
            });
        }
            try{
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
            //shutdown() 代表关闭线程池（等待所有线程完成）
            //shutdownNow() 代表立即终止线程池的运行，不等待线程,不推荐使用
            threadPool.shutdown();

        }
    }

ScheduledThreadPool

package com.caiweiwei.lianxi.controller;

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

public class ThreadPoolSample4 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService= Executors.newScheduledThreadPool(5);//可调度线程池
         /*//延迟三秒执行一次Run方法
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟3秒执行");
            }
        } , 3 , TimeUnit.SECONDS);*/
        //Timer , 项目实际开发中scheduledThreadPool与Timer都不会用到，应为有成熟的调度框架Quartz，或者Spring自带调度，
        //程序的调度框架支持一种表达式叫做Cron表达式，有兴趣的童鞋可以了解一下。
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(new Date() + "延迟1秒执行，每三秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);
    }
    }