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

Posted 叶不修233

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java——使用多线程从list中不重复地取出数据并进行处理,给多线程任务添加单项任务计时和总耗时相关的知识,希望对你有一定的参考价值。

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.运行结果

如图所示

以上是关于Java——使用多线程从list中不重复地取出数据并进行处理,给多线程任务添加单项任务计时和总耗时的主要内容,如果未能解决你的问题,请参考以下文章

java取List中重复的数据!

Java的Collection框架细节点

JAVA中的List里的Map 如何去除重复的Key?

怎样从java集合类set中取出数据?

java中怎么取两个数组中不相同的数据?

java list