线程池Executors

线程池Executors

• 为什么要使用线程池

在以后开发中，会有大量线程，线程经历的流程是：

1. 创建线程
2. 创建任务
3. 执行任务
4. 关闭线程

1和2很花时间，导致浪费大量的时间。

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

线程池的好处

1. 降低资源消耗。
2. 提高响应速度。
3. 提高线程的可管理性。

从A开始占用

A结束后，下一个任务不会去占用D，而去占用A。

Java中的四种线程池 . ExecutorService

1.缓存线程池

(长度无限制) 执行流程:

• 判断线程池是否存在空闲线程
• 存在则使用
• 不存在,则创建线程 并放入线程池, 然后使用

package xcc;

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

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
    
    
            @Override
            public void run() {
    
    try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
                System.out.println(Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        });
        try {
    
    
            Thread.sleep(2000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        service.execute(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(Thread.currentThread().getName());
            }
        });
    }
}

2.定长线程池

(长度是指定的数值)
执行流程:

• 判断线程池是否存在空闲线程
• 存在则使用
• 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
• 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

package xcc;

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

public class Demo03 {
    
    
    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());
                try {
    
    
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(Thread.currentThread().getName());
                try {
    
    
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(Thread.currentThread().getName());
                try {
    
    
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
        });
    }
}

扫描二维码关注公众号，回复： 13127703 查看本文章

3.单线程池

执行流程:

• 判断线程池 的那个线程 是否空闲
• 空闲则使用
• 不空闲,则等待 池中的单个线程空闲后 使用

package xcc;

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

public class Demo04 {
    
    
    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());
            }
        });
    }
}

4.周期定长线程池

执行流程:

• 判断线程池是否存在空闲线程
• 存在则使用
• 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
• 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

package xcc;

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

public class Demo05 {
    
    
    public static void main(String[] args) {
    
    
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * schedule:定时执行一次
         * 参数：1.定时执行的任务
         * 2.时间的数字
         * 3.时间的单位，TimeUnit的常量指定
         */
        service.schedule(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(Thread.currentThread().getName());
            }
        },5, TimeUnit.SECONDS);
        /**
         *周期执行任务
         * 参数：1.任务
         * 2.延迟时长数字
         * 3.周期执行数字
         * 4.时间单位
         */
        service.scheduleAtFixedRate(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(Thread.currentThread().getName());
            }
        },5,1,TimeUnit.SECONDS);
    }
}