线程池

开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第13天，点击查看活动详情

线程池的基本使用

1.线程池基本使用

public class EveryOneTask {
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
           Thread thread = new Thread(new Tasks());
           thread.start();
        }
    }
}
class Tasks implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" 执行了任务");

    }
}

运行结果:

1.FixedThreadPool使用

package com.imooc.jedis;

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

public class FixedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 1000; i++) {
            executorService.execute(new Task());
        }
    }
}

class Task implements Runnable{

    @Override
    public void run() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName());
    }
}

结果：

代码说明：

• Task implements Runnable：线程实现Runnable类
• ExecutorService executorService = Executors.newFixedThreadPool(4):创建newFixedThreadPool对象

3.FixedThreadPool出错情况

public class FixedThreadPoolOOM {
    public static void main(String[] args) {
      ExecutorService executorService =  Executors.newFixedThreadPool(1);
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            executorService.execute(new subThread());
        }
    }
}
class subThread implements Runnable{

    @Override
    public void run() {
        try {
            Thread.sleep(1000000000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName());
    }
}

运行结果: 代码说明:

• Executors.newFixedThreadPool(1):线程设置成1
• Thread.sleep(1000000000)：执行时间尽可能长

4.newSingleThreadExecutor

newSingleThreadExecutor 是啥？这个线程池只有一个线程newSingleThreadExecutor() 方法可以创建一次执行单个任务的执行程序

public class SingleThreadExcutor {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10000; i++) {
            executorService.execute(new Tasks());
        }
    }
}
class Task implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

运行结果：
查看源码： 核心线程和最大线程数量都是1，采用的队列是LinkedBlockingQueue无限队列

5.newScheduledThreadPool(定时线程池)

public class ScheduleThreadPoolTest {
    public static void main(String[] args) {
        ScheduledExecutorService schedule = Executors.newScheduledThreadPool(10);
//        schedule.schedule(new Tasks(),2, TimeUnit.SECONDS);
        schedule.scheduleAtFixedRate(new Tasks(),1,3,TimeUnit.SECONDS);


    }
}

运行结果： 代码说明:

• scheduleAtFixedRate(new Tasks(),1,3,TimeUnit.SECONDS):1秒的时候开始执行，每个3秒执行一次
• TimeUnit.SECONDS：单位为秒 查看源码：
• Integer.MAX_VALUE：最大整型数
• new DelayedWorkQueue()：使用的是延迟队列

6.newCachedThreadPool(可缓存线程池)

特点：具有自动回收多余线程的功能 缺点:Integer.MAX_VALUE会导致创建很多的线程，造成oom错误

public class CacheThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; i++) {
            executorService.execute(new Tasks());
        }
    }
}

运行结果：

源码：

• new SynchronousQueue()：采用直接交换队列
• 60L : 60秒自动回收