java中的线程池

线程池

1、什么是线程池

	一个线程执行流程是，创建线程-->执行线程-->关闭线程，我们可以看到这个流程中有大量的创建和关闭操作，这很消耗资源，并且浪费时间，这时候，我们就可以创建一个容器，这个容器有多个线程，不用创建，来了一个线程直接从池子里面拿去运行就好了，这就是线程池

2、线程池的好处

1、降低资源消耗
2、降低时间消耗
3、提高线程的可管理性

3、java中的几种线程池

首先创建一个公共的任务类

class Task implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "使用了线程池");
    }
}

（1）、可变长度的线程池

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

public class CachedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService sercice = Executors.newCachedThreadPool();
        Runnable task = new Task();
        sercice.execute(task);
        sercice.execute(task);
        sercice.execute(task);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sercice.execute(task);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sercice.execute(task);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sercice.execute(task);
    }
}

（2）、固定长度的线程池

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

public class FixedTreadPoolTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        Task task = new Task();
        service.execute(task);
        service.execute(task);
        service.execute(task);
    }
}

（3）、单线线程池

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

public class SingleThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService serice = Executors.newSingleThreadExecutor();
        Task task = new Task();
        serice.execute(task);
        serice.execute(task);
    }
}

（4）、周期定长线程池

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

/**
 * 周期定长线程池的使用
 */
public class ScheduleFixedThreadPoolTest {
    public static void main(String[] args) {
        ScheduledExecutorService s = Executors.newScheduledThreadPool(2);
        Task task = new Task();
        /**
         * 参数说明
         * 参数1. 定时执行的任务
         * 参数2. 执行该任务需要等待的时长
         * 参数3. 修饰参数2的时长是什么单位的（例如：时分秒）
         */
        s.schedule(task,3, TimeUnit.SECONDS);
        /**
         * 按照固定的速录运行该任务
         * 参数1. 执行的任务
         * 参数2. 第一次执行的任务需要等待的时间
         * 参数3. 时间间隔
         * 参数4. 修饰参数2和参数3究竟是是什么单位
         */
        s.scheduleAtFixedRate(task,3,1,TimeUnit.SECONDS);
    }
}