线程池中的饥饿问题和定时延时任务和异常处理

线程数量不足导致的饥饿
固定大小的线程池会有饥饿现象

static final List<String> MENU = Arrays.asList("地三鲜","宫保鸡丁","辣子鸡丁","烤鸡翅");
static Random RANDOM = new Random();
static String cooking(){ return MENU.get(RANDOM.nextInt(MENU.size())); }
public static void main(String[] args) {
    // 由于线程数不够导致的饥饿
    ExecutorService pool = Executors.newFixedThreadPool(2);
    pool.execute(() -> {
        log.debug("处理点餐...");
        Future<String> f = pool.submit(() -> {
            log.debug("做菜");// 没有线程去执行做菜任务了
            return cooking();
        });
        try {
            log.debug("上菜：{}",f.get());// 死等
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    });
    pool.execute(() -> {
        log.debug("处理点餐...");
        Future<String> f = pool.submit(() -> {
            log.debug("做菜");// 没有线程去执行做菜任务了
            return cooking();
        });
        try {
            log.debug("上菜：{}",f.get());// 死等
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    });
}

解决饥饿现象，不同的任务使用不同的线程池

ExecutorService waiterPool = Executors.newFixedThreadPool(1);
ExecutorService cookPool = Executors.newFixedThreadPool(1);

waiterPool.execute(() -> {
    log.debug("处理点餐...");
    Future<String> f = cookPool.submit(() -> {
        log.debug("做菜");
        return cooking();
    });
    try {
        log.debug("上菜：{}",f.get());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
});
waiterPool.execute(() -> {
    log.debug("处理点餐...");
    Future<String> f = cookPool.submit(() -> {
        log.debug("做菜");
        return cooking();
    });
    try {
        log.debug("上菜：{}",f.get());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
});

线程池多大合适

// 1.CPU密集型运算
线程个数采用:(CPU核数 + 1)较为合适
// 2.IO密集型运算
线程个数可以多一点

希望任务延时执行，反复被执行，需要用任务调度线程池

// jdk1.3
java.util.Timer可以实现相关功能
但是所有的任务都是同一个线程来执行,因此是串行的,前一个任务的延迟或异常都会影响到后面的任务
Timer timer = new Timer();
TimerTask task1 = new TimerTask() {
    @Override
    public void run() {
        log.debug("task 1");
        int i = 1 / 0; // 任务2直接不执行了
    }
};
TimerTask task2 = new TimerTask() {
    @Override
    public void run() {
        log.debug("task 2");
    }
};
log.debug("start....");
timer.schedule(task1,1000);
timer.schedule(task2,1000);
// jdk1.5
// 延时执行
ScheduledExecutorService pool = Executors.newScheduledThreadPool(1); // 线程数为1的话还是会串行执行
pool.schedule(() -> {
    log.debug("task1");
    int i = 1 / 0; // 后面的任务会正常执行
},3,TimeUnit.SECONDS); // 延时执行任务,3秒后执行
pool.schedule(() -> log.debug("task2"),4,TimeUnit.SECONDS);
// 定时执行
ScheduledExecutorService pool = Executors.newScheduledThreadPool(7);
log.debug("start...");
pool.scheduleAtFixedRate(() -> {
    log.debug("running");
    try {
        TimeUnit.SECONDS.sleep(2);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
},1,1,TimeUnit.SECONDS); // 1s后执行,每2s执行一次,串行
pool.scheduleWithFixedDelay(() -> {
    log.debug("running");
    try {
        TimeUnit.SECONDS.sleep(2);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
},1,1,TimeUnit.SECONDS); // 1s后执行,上次任务执行完延迟1s后执行下一任务(相当于每3s执行一次)

线程池异常处理

ExecutorService pool = Executors.newFixedThreadPool(1);
Future<Boolean> f = pool.submit(() -> {
    log.debug("task running");
    int i = 1 / 0;  // default 不会抛出异常
    return true;
});
// get方法会判断task的运行状态,如果为EXCEPTIONAL,会抛出异常
// FutureTask类中会维护task的运行状态(详见其run方法和setException方法)
log.debug("result:{}",f.get());

// 也可以在可能出现异常的地方手动try catch处理

定时任务

// 每周四18:00:00定时执行任务
public static void main(String[] args) {
    // 当前时间
    LocalDateTime now = LocalDateTime.now();
    // 本周中的(周四18:00:00)
    LocalDateTime taskTime = now.withHour(18).withMinute(0).withSecond(0).withNano(0).with(DayOfWeek.THURSDAY);
    // 当前时间 > 本周(周四18:00:00)
    if(now.compareTo(taskTime) > 0){
        taskTime = taskTime.plusWeeks(1);// 下周四
    }

    long initialDelay = Duration.between(now,taskTime).toMillis();
    long period = 1000 * 60 * 60 * 24 * 7; // 任务时间间隔(一周)
    ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
    pool.scheduleAtFixedRate(() -> {
        System.out.println("running");
    },initialDelay,period, TimeUnit.MILLISECONDS);
}