Java——使用多线程从list中不重复地取出数据并进行处理，给多线程任务添加单项任务计时和总耗时

一、最简版-无参数传递

1.创建业务类，实现Runnable接口

把处理数据的方法写在处理类中重写的Runnable接口的run()方法中。

import lombok.extern.slf4j.Slf4j;


import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class Demo01Runnable implements Runnable {

    //实现父接口Runnable中的run方法
    @Override
    public void run() {
        //调用自己的业务方法
        doSomething();
    }

    //自己业务的方法
    private void doSomething() {
        log.info("随便干点啥...");
    }
}

2.创建线程，实例化自己创建的业务类并调用

@Slf4j
@Service
public class FileOperateService {

    // 业务处理的线程池(设置为4个线程)
    private static ExecutorService pool = Executors.newFixedThreadPool(4);

    //在这里调用
	public static void main(String[] args) {
        //创建一个Runnable对象，并将CountDownLatch的实例对象传入
        Demo01Runnable runnable = new Demo01Runnable();
        for (int i = 0; i < 4; i++) {
            //从线程池取出一个线程来执行业务，遍历4次就是取出4个
            pool.execute(runnable);
        }
    }
}

3.运行结果

如图所示可以看到创建了4个线程

二、加强版-有参数传递

大部分的业务都不是独立运行的，会有参数传递到业务中，如果需要多线程调用的业务有主线程的参数需要传递过去，就可以把参数写在实现了Runnable接口的业务类的私有属性中，用业务类的构造方法传参。具体代码改造如下：

1.创建业务类，实现Runnable接口

• 添加了私有属性Integer num

• 添加了num的构造方法

• 在方法中调用了属性num

import lombok.extern.slf4j.Slf4j;


import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class Demo02Runnable implements Runnable {
    private Integer num;

    public Demo02Runnable(Integer num){
        this.num = num;
    }

    //实现父接口Runnable中的run方法
    @Override
    public void run() {
        //调用自己的业务方法
        doSomething();
    }

    //自己业务的方法
    private void doSomething() {
        log.info("第 {} 个线程开始干活", num);
    }
}

2.创建线程，实例化自己创建的业务类并调用

• new Demo02Runnable对象时候将num作为参数传递构造方法中

@Slf4j
@Service
public class FileOperateService {

    // 业务处理的线程池(设置为4个线程)
    private static ExecutorService pool = Executors.newFixedThreadPool(4);

    //在这里调用
	public static void main(String[] args) {

        for (int i = 0; i < 4; i++) {
            //创建一个Runnable对象，并将CountDownLatch的实例对象传入
            Demo02Runnable runnable = new Demo02Runnable(i);
            //从线程池取出一个线程来执行业务，遍历4次就是取出4个
            pool.execute(runnable);
        }
    }
}

3.运行结果

如图所示可以看到参数成功传递进去了

三、加加强版-有参数传递且带单项任务计时和总耗时

在业务里，使用多个线程并行处理业务能够极大的加快处理速度，但是如果我们需要明确掌握每次处理业务的耗时，和所有业务处理完成的总耗时，就可以通过CountDownLatch来帮我们实现。

1.创建业务类，实现Runnable接口

• 添加了私有属性：

  • Integer size -用来记录任务的总数量
  • long ct -用来记录任务开始的时间
  • AtomicInteger taskProgress -用来记录任务执行的数量
  • CountDownLatch latch -用来统计单项任务计时和总耗时

• 添加了以上属性的构造方法

• 在方法中调用了以上属性

import lombok.extern.slf4j.Slf4j;


import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class Demo03Runnable implements Runnable {
    private Integer size;
    private long ct;
    private AtomicInteger taskProgress;
    private CountDownLatch latch;
    
    public Demo03Runnable(Integer size, long ct, AtomicInteger taskProgress, CountDownLatch latch){
        this.size = size;
        this.ct = ct;
        this.taskProgress = taskProgress;
        this.latch = latch;
    }

    //实现父接口Runnable中的run方法
    @Override
    public void run() {
        //调用自己的业务方法
        doSomething();
    }

    //自己业务的方法
    private void doSomething() {
        //从系统获取业务开始执行时的时间
        long curr = System.currentTimeMillis();
        try {
            //线程睡0.5秒来代替任意业务逻辑
            Thread.sleep(500);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            //让CountDownLatch计数器减1
            latch.countDown();
            //统计任务数量，即本条业务被线程执行的次数（每执行一次就+1
            int task = taskProgress.getAndIncrement();
            log.info("任务进度 {} / {} = {}%\t {} 号任务耗时：{} - 任务总耗时：{} ", task, size, String.format("%.2f", task * 100.0 / size), task, System.currentTimeMillis() - curr, System.currentTimeMillis() - ct);

        }
    }
}

2.创建线程，实例化自己创建的业务类并调用

• 任务开始前，创建CountDownLatch对象用于在指定位置控制所有子线程完成后再走主线程指定代码
• 任务开始前，从系统获取当前时间作为任务开始时间
• 任务开始前，创建AtomicInteger用于统计任务执行数量
• 创建Demo03Runnable对象时候将size（任务总数量），ct（任务开始时间），taskProgress（任务执行数量），latch作为参数传递构造方法中
• 主线程中调用子线程的方法结束后，调用await()方法，阻塞主线程，在这之后的代码只会在子线程全部执行完成之后，才开始执行。因此在这里再次获取系统当前时间，用于和前面记录的时间计算后统计相关耗时。

@Slf4j
@Service
public class FileOperateService {

    // 业务处理的线程池(设置为4个线程)
    private static ExecutorService pool = Executors.newFixedThreadPool(4);

    //在这里调用
	public static void main(String[] args) {

        //创建一个CountDownLatch对象，并调用构造器将计数器设置为总任务数量
        CountDownLatch latch = new CountDownLatch(10);
        //记录任务开始时间
        long ct = System.currentTimeMillis();
        //记录任务开始数量
        final AtomicInteger taskProgress = new AtomicInteger(1);
        for (int i = 1; i <= 10; i++) {
            //创建一个Runnable对象，并将CountDownLatch的实例对象传入
            Demo03Runnable runnable = new Demo03Runnable(10,ct,taskProgress,latch);
            pool.execute(runnable);
        }
        //调用await()方法，阻塞主线程，当上述启动的所有分线程都执行完后，主线程才会被放行
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //记录下结束时间
        log.info("任务全部执行完成，总耗时：{} 毫秒", System.currentTimeMillis() - ct);
    }
}

3.运行结果

如图所示