java线程池ThreadPoolTaskExecutor示例

1.什么是ThreadPoolTaskExecutor

ThreadPoolTaskExecutor是Spring基于java本身的线程池ThreadPoolExecutor做的二次封装，主要目的还是为了更加方便的在spring框架体系中使用线程池。

2.ThreadPoolTaskExecutor示例

package cn.enn.purchase.manager.service.impl;


import cn.enn.purchase.manager.service.TestService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;


@Service
@Slf4j
public class TestServiceImpl implements TestService {

    @Resource
    private ThreadPoolTaskExecutor poolTaskExecutor;

    @Transactional(rollbackFor = Exception.class)
    public void setProviderLabels() throws InterruptedException {

        long t1 = System.currentTimeMillis();
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        //计数器
        CountDownLatch countDownLatch = new CountDownLatch(list.size());
        int a = 0;
        for (Integer num : list) {
            a++;
            System.out.println("循环次数:"+ a + "进来的内容:"+num);
            //调用线程执行任务
            poolTaskExecutor.submit(()->buildList(num,countDownLatch));
        }
        //
        countDownLatch.await();
        long t2 = System.currentTimeMillis();
        log.info("处理供应商数据耗时:{}毫秒",t2-t1);
    }


    private void buildList(Integer num, CountDownLatch countDownLatch){
        try{
            System.out.println("多线程处理逻辑进来了:"+ num);
        }catch (Exception e){
            log.error("buildList error :{}",e.getMessage());
        }finally {
            //计数器减1
            countDownLatch.countDown();
        }
    }

}

package cn.enn.purchase.manager.service;


public interface TestService {


    void setProviderLabels() throws InterruptedException;
}

package cn.enn.purchase.manager;

import cn.enn.purchase.manager.service.TestService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

/**
 * 单元测试
 */
@ActiveProfiles("dev")
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class ThreadPoolTaskExecutorTest {

    @Resource
    private TestService testService;

    @Test
    public void aaaaTest() throws InterruptedException {
        //调用方法
        testService.setProviderLabels();
    }


}

-------------------------------《执行结果》---------------------

循环次数:1进来的内容:1
循环次数:2进来的内容:2
循环次数:3进来的内容:3
循环次数:4进来的内容:4
多线程处理逻辑进来了:1
多线程处理逻辑进来了:2
循环次数:5进来的内容:5
多线程处理逻辑进来了:3
多线程处理逻辑进来了:4
循环次数:6进来的内容:6
多线程处理逻辑进来了:5
循环次数:7进来的内容:7
循环次数:8进来的内容:8
多线程处理逻辑进来了:6
循环次数:9进来的内容:9
多线程处理逻辑进来了:7
多线程处理逻辑进来了:8
多线程处理逻辑进来了:9

 

一、什么是countDownlatch

CountDownLatch是一个同步工具类，它通过一个计数器来实现的,初始值为线程的数量。每当一个线程完成了自己的任务,计数器的值就相应得减1。当计数器到达0时,表示所有的线程都已执行完毕,然后在等待的线程就可以恢复执行任务。

二、方法详解

1. CountDownLatch(int count)：count为计数器的初始值（一般需要多少个线程执行，count就设为几）。
2. countDown(): 每调用一次计数器值-1，直到count被减为0，代表所有线程全部执行完毕。
3. getCount()：获取当前计数器的值。
4. await(): 等待计数器变为0，即等待所有异步线程执行完毕。
5. boolean await(long timeout, TimeUnit unit)： 此方法与await()区别：
   ①此方法至多会等待指定的时间，超时后会自动唤醒，若 timeout 小于等于零，则不会等待
   ②boolean 类型返回值：若计数器变为零了，则返回 true；若指定的等待时间过去了，则返回 false

三、CountDownLatch应用场景 

1. 某个线程需要在其他n个线程执行完毕后再向下执行
2. 多个线程并行执行同一个任务，提高响应速度