java内置线程池

线程池常见方法

如何获取线程池对象

缓存线程池

自定义任务对象

public class MyRunnable implements Runnable{

    private int id;

    public MyRunnable(int id) {
        this.id = id;
    }


    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println("线程" + name + "开始执行任务" + id);
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程" + name + "完成任务" + id);
    }


    @Override
    public String toString() {
        return "MyTask{" +
                "id=" + id +
                '}';
    }
}

获取线程池对象

 ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
 for (int i = 0; i < 100; i++) {
     MyRunnable myRunnable = new MyRunnable(i);
     cachedThreadPool.execute(myRunnable);
 }

固定线程池

• Executors.newFixedThreadPool(5) 5 代表线程最大数量
• 顾名思义：最大不会超过5个线程

  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
  for (int i = 0; i < 10; i++) {
      MyRunnable myRunnable = new MyRunnable(i);
      fixedThreadPool.execute(myRunnable);
  }

单例线程池

• 无论多少任务，我就一个线程
• newSingleThreadExecutor 方法

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
 for (int i = 0; i < 10; i++) {
     MyRunnable myRunnable = new MyRunnable(i);
     singleThreadExecutor.execute(myRunnable);
 }

延迟调用的线程池

• newScheduledThreadPool 创建线程池
• schedule 提交线程任务
• 分为可复用和单例线程池

//        创建延迟调用线程池
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
for (int i = 0; i < 10; i++) {
    MyRunnable myRunnable = new MyRunnable(i);
//            延迟3秒执行
    scheduledThreadPool.schedule(myRunnable, 3, TimeUnit.SECONDS);
}

for (int i = 0; i < 10; i++) {
    MyRunnable myRunnable = new MyRunnable(i);
//            初始为1秒，每次执行的间隔为3秒 间隔是上一个任务开始到下一个任务开始的时间
    scheduledThreadPool.scheduleAtFixedRate(myRunnable, 1, 3, TimeUnit.SECONDS);
}

for (int i = 0; i < 10; i++) {
    MyRunnable myRunnable = new MyRunnable(i);
//            延迟1秒后每3秒执行一次 间隔是上一个任务结束到下一个任务开始的时间
    scheduledThreadPool.scheduleWithFixedDelay(myRunnable, 1, 3, TimeUnit.SECONDS);
}

线程池如何接受运算结果

定义一个callable类型

// T是泛型，表示返回结果的类型
public class MyCallable<T> implements Callable<T> {

    private int i;

    public MyCallable(int i) {
        this.i = i;
    }

    @Override
    public T call() throws Exception {
        // 返回一个T类型的对象
        return (T) (Thread.currentThread().getName() + "返回结果 " + i);
    }

    @Override
    public String toString() {
        return "MyCallable{" +
                "i=" + i +
                '}';
    }
}

• 对于Callable，使用submit会有一个Future 的返回值
• future.get()方法会阻塞直到线程执行完毕

// 创建一个固定大小的线程池
 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
 // 创建一个Future列表 用于存放线程执行结果 泛型是String
 List<Future<String>> futureList = new ArrayList<>();
 for (int i = 0; i < 10; i++) {
     MyCallable<String> myCallable = new MyCallable(i);
     // 提交任务到线程池
     Future<String> future = fixedThreadPool.submit(myCallable);
     // 将线程执行结果存放到Future列表
     futureList.add(future);
 }
 for (Future<String> future : futureList) {
     try {
         // 获取线程执行结果 返回是outcome 类型是T
         // get()方法会阻塞直到线程执行完毕
         System.out.println(future.get());
     } catch (InterruptedException | ExecutionException e) {
         e.printStackTrace();
     }
 }
 // 关闭线程池
 fixedThreadPool.shutdown();