多线程(七)并发工具包与线程池

–java.util.concurrent

–并发是伴随这多核处理器的诞生而产生的, 为了充分利用硬件资源, 诞生了多线程技术, 但是多线程又存在资源竞争的问题, 引发了同步和互斥的问题, JDK1.5推出的java.util.concurrent(并发工具包) 来解决这些问题

–new Thread的弊端

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

–ThreadPool - 线程池

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

–线程池的种类

在java.util.concurrent中, 提供了工具类Executors(调度器)对象来创建线程池

• –CachedThreadPool - 可缓存线程池
• –FixedThreadPool - 定长线程池
  • –如果任务处于等待的状态, 备选的等待算法为FIFO(先进先出) LIFO(后进先出)
• –SingleThreadExecutor - 单线程池
• –ScheduledThreadPool - 调度线程池

–CachedThreadPool() 可缓存线程池

package com.ygq.thread.threadPool;

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

/**
 * @author ：GQ.Yin
 * @date ：Created in 2019/7/22 12:32
 * @description：可缓存线程池示例
 * @version: $version$
 */
public class ThreadPoolSample1 {
    public static void main(String[] args) {
        //调度器对象
        //ExecutorService用于管理线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();//创建一个可缓存线程池
        //可缓存线程池的特点是, 无限大, 如果线程池中没有可用的线程则创建, 有空闲的则使用
        for (int i = 0; i < 1000; i++) {
            final int index = i;
            threadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " : " + index);
                }
            });
        }
        //shutdown() 代表关闭线程池(等待所有线程完成)
        threadPool.shutdown();

        //shutdownNow() 代表立即终止线程池的运行, 不等待线程, 不推荐使用
//        threadPool.shutdownNow();
    }
}

–定长线程池

package com.ygq.thread.threadPool;

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

/**
 * @author ：GQ.Yin
 * @date ：Created in 2019/7/22 12:57
 * @description：定长线程池示例
 * @version: $version$
 */
public class ThreadPoolSample2 {
    public static void main(String[] args) {
        //调度器对象
        //ExecutorService用于管理线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(3); //创建一个固定线程池
        //定长线程池的特点是, 线程池中最多只能有固定数量的线程同时运行
        //如果任务处于等待的状态, 备选的等待算法为FIFO(先进先出)  LIFO(后进先出)
        for (int i = 0; i < 1000; i++) {
            final int index = i;
            threadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName()+" : " + index);
                }
            });
        }

        //关闭线程池
        threadPool.shutdown();
    }
}

–SingleThreadExecutor() 单线程池

package com.ygq.thread.threadPool;

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

/**
 * @author ：GQ.Yin
 * @date ：Created in 2019/7/22 13:09
 * @description：单线程池
 * @version: $version$
 */
public class ThreadPoolSample3 {
    public static void main(String[] args) {
        //Executors线程调度器
        ExecutorService threadPool = Executors.newSingleThreadExecutor();  //创建一个单线程池

        for (int i = 0; i < 1000; i++) {
            final int index = i;
            threadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " : " + index);
                }
            });
        }
        //关闭线程池
        threadPool.shutdown();
    }
}

–ScheduledExecutorService

package com.ygq.thread.threadPool;

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

/**
 * @author ：GQ.Yin
 * @date ：Created in 2019/7/22 13:20
 * @description：可调动的线程池
 * @version: $version$
 */
public class ThreadPoolSample4 {
    public static void main(String[] args) {

        ScheduledExecutorService scheduleThreadPool = Executors.newScheduledThreadPool(5);

        //延时3秒执行一次run方法, schedule除了需要传入Runnable之外, 还需要传入具体的数量, 以及 单位
//        scheduleThreadPool.schedule(new Runnable() {
//            public void run() {
//                System.out.println("延时3秒执行");
//            }
//        }, 3, TimeUnit.SECONDS);

        //延时1秒, 每3秒执行一次
        scheduleThreadPool.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("延迟1秒执行, 每三秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);

        /**
         * 实际开发中, 使用比较少
         * 因为有成熟的调度框架Quartz
         * 或者Spring 自带调度
         *     成熟的调度框架执行一种表达式, 叫Cron表达式
         */
    }
}

–线程池经典应用