精华内容
下载资源
问答
  • 主要介绍了Java多线程处理List数据,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 多线程数量的问题,一般情况下,多线程数量要等于机器CPU核数-1. 实例1: 解决问题:如何让n个线程顺序遍历含有n个元素的List集合 1 import java.util.ArrayList; 2 import java.util.List; 3 import ...

    多线程数量的问题,一般情况下,多线程数量要等于机器CPU核数-1.

    实例1:

    解决问题:如何让n个线程顺序遍历含有n个元素的List集合

     

     1 import java.util.ArrayList;
     2 import java.util.List;
     3 import org.apache.commons.lang3.ArrayUtils;
     4  
     5 public class Test_4 {
     6     /**
     7      * 多线程处理list
     8      *
     9      * @param data  数据list
    10      * @param threadNum  线程数
    11      */
    12     public synchronized void handleList(List<String> data, int threadNum) {
    13         int length = data.size();
    14         int tl = length % threadNum == 0 ? length / threadNum : (length
    15                 / threadNum + 1);
    16  
    17         for (int i = 0; i < threadNum; i++) {
    18             int end = (i + 1) * tl;
    19             HandleThread thread = new HandleThread("线程[" + (i + 1) + "] ",  data, i * tl, end > length ? length : end);
    20             thread.start();
    21         }
    22     }
    23  
    24     class HandleThread extends Thread {
    25         private String threadName;
    26         private List<String> data;
    27         private int start;
    28         private int end;
    29  
    30         public HandleThread(String threadName, List<String> data, int start, int end) {
    31             this.threadName = threadName;
    32             this.data = data;
    33             this.start = start;
    34             this.end = end;
    35         }
    36         
    37         public void run() {
    38             List<String> subList = data.subList(start, end)/*.add("^&*")*/;
    39             System.out.println(threadName+"处理了"+subList.size()+"条!");
    40         }
    41  
    42     }
    43  
    44     public static void main(String[] args) {
    45         Test_4 test = new Test_4();
    46         // 准备数据
    47         List<String> data = new ArrayList<String>();
    48         for (int i = 0; i < 6666; i++) {
    49             data.add("item" + i);
    50         }
    51         test.handleList(data, 5);
    52         System.out.println(ArrayUtils.toString(data));
    53     }
    54 }
    View Code

     

    实例2:

    List多线程并发读取读取现有的list对象

     1 //测试读取List的线程类,大概34秒
     2 package com.thread.list;
     3  
     4 import java.util.ArrayList;
     5 import java.util.HashMap;
     6 import java.util.List;
     7 import java.util.Map;
     8  
     9 public class Main {
    10     
    11     public static void main(String[] args) {
    12         
    13         List<String> list = new ArrayList<String>();
    14         Map<Long,Integer> map = new HashMap<Long,Integer>();
    15 
    16         for(int i = 0;i<1000;i++){
    17             list.add(""+i);
    18         }
    19         
    20         int pcount = Runtime.getRuntime().availableProcessors();        
    21         long start = System.currentTimeMillis();        
    22         
    23         for(int i=0;i<pcount;i++){
    24             
    25            Thread t = new MyThread1(list,map);
    26             map.put(t.getId(),Integer.valueOf(i));
    27             t.start();
    28             try {
    29                 t.join();
    30             } catch (InterruptedException e) {              
    31                 e.printStackTrace();
    32             }            
    33            // System.out.println(list.get(i));
    34         }        
    35         System.out.println("----"+(System.currentTimeMillis() - start));
    36     }    
    37 }
    38 
    39 //线程类
    40 package com.thread.list;
    41  
    42 import java.util.List;
    43 import java.util.Map;
    44  
    45 public class MyThread1 extends Thread {
    46  
    47     private List<String> list;
    48     private Map<Long,Integer> map;
    49     
    50     public MyThread1(List<String> list,Map<Long,Integer> map){
    51         this.list = list;
    52         this.map = map;
    53     }
    54     
    55     @Override
    56     public void run() {
    57         
    58         int pcount = Runtime.getRuntime().availableProcessors();
    59         int i = map.get(Thread.currentThread().getId());
    60         
    61         for(;i<list.size();i+=pcount){
    62             System.out.println(list.get(i));
    63         }              
    64     }    
    65 }
    View Code

    实例3:

    多线程分段处理List集合

    场景:大数据List集合,需要对List集合中的数据同标准库中数据进行对比,生成新增,更新,取消数据
    解决方案:

    1. List集合分段,
    2. 动态创建线程池newFixedThreadPool
    3. 将对比操作在多线程中实现
     1 public static void main(String[] args) throws Exception {
     2 
     3         // 开始时间
     4         long start = System.currentTimeMillis();
     5         List<String> list = new ArrayList<String>();
     6 
     7         for (int i = 1; i <= 3000; i++) {
     8             list.add(i + "");
     9         }
    10         // 每500条数据开启一条线程
    11         int threadSize = 500;
    12         // 总数据条数
    13         int dataSize = list.size();
    14         // 线程数
    15         int threadNum = dataSize / threadSize + 1;
    16         // 定义标记,过滤threadNum为整数
    17         boolean special = dataSize % threadSize == 0;
    18 
    19         // 创建一个线程池
    20         ExecutorService exec = Executors.newFixedThreadPool(threadNum);
    21         // 定义一个任务集合
    22         List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();
    23         Callable<Integer> task = null;
    24         List<String> cutList = null;
    25 
    26         // 确定每条线程的数据
    27         for (int i = 0; i < threadNum; i++) {
    28             if (i == threadNum - 1) {
    29                 if (special) {
    30                     break;
    31                 }
    32                 cutList = list.subList(threadSize * i, dataSize);
    33             } else {
    34                 cutList = list.subList(threadSize * i, threadSize * (i + 1));
    35             }
    36             // System.out.println("第" + (i + 1) + "组:" + cutList.toString());
    37             final List<String> listStr = cutList;
    38             task = new Callable<Integer>() {
    39 
    40                 @Override
    41                 public Integer call() throws Exception {
    42                     System.out.println(Thread.currentThread().getName() + "线程:" + listStr);
    43                     return 1;
    44                 }
    45             };
    46             // 这里提交的任务容器列表和返回的Future列表存在顺序对应的关系
    47             tasks.add(task);
    48         }
    49 
    50         List<Future<Integer>> results = exec.invokeAll(tasks);
    51 
    52         for (Future<Integer> future : results) {
    53             System.out.println(future.get());
    54         }
    55 
    56         // 关闭线程池
    57         exec.shutdown();
    58         System.out.println("线程任务执行结束");
    59         System.err.println("执行任务消耗了 :" + (System.currentTimeMillis() - start) + "毫秒");
    60     }
    View Code

    转载于:https://www.cnblogs.com/huangdabing/p/9251598.html

    展开全文
  • java多线程批量处理list集合中的数据

    万次阅读 2019-05-10 17:50:10
    public class ThreadList { public static void main(String[] args) throws InterruptedException, ExecutionException ... List<String> list = new ArrayList<>(); for(int i=0;i<5300;i+...
    public class ThreadList {
    
    	public static void main(String[] args) throws InterruptedException, ExecutionException {
    		List<String> list = new ArrayList<>();
    		
    		for(int i=0;i<5300;i++){
    			list.add(""+i);
    		}
    		int threadSize = 500;//每500条数据开启一个线程
    		int remainder = list.size()%threadSize;
    		int threadNum  = 0;//线程数
    		if(remainder == 0){
    			threadNum  = list.size()/threadSize;
    		} else {
    			threadNum  = list.size()/threadSize + 1;
    		}
    		
    		ExecutorService eService = Executors.newFixedThreadPool(threadNum );//创建一个线程池
    		
    		List<Callable<String>> cList = new ArrayList<>(); 
    		Callable<String> task = null;
    		List<String> sList = null;
    		
    		for(int i=0;i<threadNum;i++){
    			if(i == threadNum - 1){
    				sList = list.subList(i*threadSize, list.size());
    			} else {
    				sList = list.subList(i*threadSize, (i+1)*threadSize);
    			}
    			final List<String> nowList = sList;
    			task = new Callable<String>() {
    				@Override
    				public String call() throws Exception {
    					StringBuffer sb = new StringBuffer();
    					for(int j=0;j<nowList.size();j++){
    						sb.append(""+nowList.get(j));
    					}
    					return sb.toString();
    				}
    			};
    			cList.add(task);
    		}
    		List<Future<String>> results = eService.invokeAll(cList);
    		for(Future<String> str:results){
    			System.out.println(str.get());
    		}
    		eService.shutdown();
    	}
    }

     

    展开全文
  • java多线程的使用(处理list集合)

    千次阅读 2020-08-06 17:14:39
    * 多线程处理list * * @param data 数据list * @param threadNum 线程数 */ public synchronized void handleList(List<String> data, int threadNum) { int length = data.size(); int tl = length %...
    /**
         * 多线程处理list
         *
         * @param data      数据list
         * @param threadNum 线程数
         */
        public synchronized void handleList(List<String> data, int threadNum) {
            int length = data.size();
            int tl = length % threadNum == 0 ? length / threadNum : (length
                    / threadNum + 1);
    
        for (int i = 0; i < threadNum; i++) {
            int end = (i + 1) * tl;
            ZppController.HandleThread thread = new ZppController.HandleThread("线程[" + (i + 1) + "] ", data, i * tl, Math.min(end, length));
            thread.start();
        }
    }
    class HandleThread extends Thread {
        private String threadName;
        private List<String> data;
        private int start;
        private int end;
    
        public HandleThread(String threadName, List<String> data, int start, int end) {
            this.threadName = threadName;
            this.data = data;
            this.start = start;
            this.end = end;
        }
    
        public void run() {
            for (int i = start; i < end; i++) {
                System.out.println(threadName + "处理了" + data.get(i));
            }
    
        }
    
    }
    

    最后写个main方法,调用一下它就ok了!
    handleList(list,5);

    展开全文
  • Java多线程分段处理List集合

    千次阅读 2018-05-21 10:00:13
    Java多线程分段处理List集合 解决方案:1.List集合分段 2.动态创建线程池newFixedThreadPool 3.多线程处理数据   代码如下:  public static void main(String[] args) throws Exception { // 开始时间 ...

    Java多线程分段处理List集合

    解决方案:
    1.List集合分段

    2.动态创建线程池newFixedThreadPool

    3.多线程处理数据

     

    代码如下:

     public static void main(String[] args) throws Exception {

    // 开始时间

    long start = System.currentTimeMillis();

    // 模拟数据

    List List<String> list = new ArrayList<String>();

    for (int i = 1; i <= 3000; i++){

    list.add(i + "");

    }

    // 每500条数据开启一条线程

    int threadSize = 500;

    // 总数据条数

    int dataSize = list.size();

    // 线程数

    int threadNum = dataSize / threadSize + 1;

    // 定义标记,过滤threadNum为整数

    boolean special = dataSize % threadSize == 0;

    // 创建一个线程池

    ExecutorService exec = Executors.newFixedThreadPool(threadNum);

    // 定义一个任务集合

    List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();

    Callable<Integer> task = null;

    List<String> cutList = null;

    // 确定每条线程的数据

    for (int i = 0; i < threadNum; i++) {

    if (i == threadNum - 1) {

    if (special) {

    break;

    }

    cutList = list.subList(threadSize * i, dataSize);

    } else {

    cutList = list.subList(threadSize * i, threadSize * (i + 1));

    }

    // System.out.println("第" + (i + 1) + "组:" + cutList.toString());

    final List<String> listStr = cutList;

    task = new Callable<Integer>() {

    @Override public

    Integer call() throws Exception {

    System.out.println(Thread.currentThread().getName() + "线程:" + listStr);

    return 1;

    }

    };

    // 这里提交的任务容器列表和返回的Future列表存在顺序对应的关系

    tasks.add(task);

    }

    List<Future<Integer>> results = exec.invokeAll(tasks);

    for (Future<Integer> future : results) {

    System.out.println(future.get());

    }

    // 关闭线程池

    exec.shutdown();

    System.out.println("线程任务执行结束");

    System.err.println("执行任务消耗了 :" + (System.currentTimeMillis() - start) + "毫秒");

    }

    展开全文
  • 多线程处理大量数据 java

    千次阅读 2020-09-27 17:12:11
    5W条数据处理后生成execl文件需要6个小时,效率慢 APP 中接收数据代码: @Override public void run() { bytes = mmInStream.read(buffer); mHandler.obtainMessage(READ_DATA, bytes, -1, buffer).sendToTarget...
  • Java多线程处理大量数据

    万次阅读 2017-04-18 22:21:10
    并发环境是非常复杂的,什么情况都有可能发生,Java给我们提供了线程调度以及同步等机制来保证多线程环境下我们的代码依然可以正确执行,下面是多个线程处理大量数据的简单实现,入门级import java.util.ArrayList;...
  • Java多线程分批处理数据

    千次阅读 2019-03-17 11:59:22
    场景:发短信,当有数据量庞大的短信需要发送时,可以采用多线程的方式分批处理以提高效率,但线程要控制合适的数量,否则会极大消耗CPU资源 上代码: 创建分页类PageUtil /** * 分页 * @param list 切割数据...
  • JAVA 多线程处理大数据LIST

    千次阅读 2017-07-01 14:55:13
    package com.sinosoft.audit; ...import java.util.ArrayList;...import java.util.Date;...import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ScheduledThre
  • Java 多线程处理集合数据

    千次阅读 2018-05-03 22:22:28
    处理一个包含10万条数据的字符串集合,将其中含有'4599'的字符串都返回。1.开启线程代码如下:import com.baidu.model.ConCallable; import com.baidu.model.PropertiesTest; import ...
  • 多线程处理List数据

    千次阅读 2018-11-04 17:26:35
    CountDownLatch进行多线程处理list 由于公司的一个辅算系统进行计算的时间比较长3万的数据需要5分钟才能算完这个完全超出了预算,我跟负责项目的同事交流之后发现代码的if 语句特别多导致臃肿等等。针对这些先了几点...
  • 功能虽然不是很强大,但是能很好的说明问题。
  • 获取导入excel文件中的数据,存入list中进行多线程处理,设定每个线程处理多少条数据,进行设定值动态启动线程数量数据,根据线程处理 数量拆分动态list数据进行相关业务操作 package com.ig.bi.game.controller; ...
  • JavaList集合使用多线程分段处理

    千次阅读 2018-12-12 10:45:31
    因业务需要,需从excel读取数据并插入数据库,由于数据量较大,耗时较长,考虑使用多线程处理 1.读取到的list数据量分段 2.动态创建线程 public class ScmcommissionLineServiceImpl{ //导入数据 public ...
  • java 多线程处理导入数据

    千次阅读 2016-12-26 11:30:07
    获取导入excel文件中的数据,存入list中进行多线程处理,设定每个线程处理多少条数据,进行设定值动态启动线程数量数据,根据线程处理 数量拆分动态list数据进行相关业务操作 package com.ig.bi.game.controller; ...
  • java 多线程并发查询mysql数据

    千次阅读 2020-09-29 17:24:01
    程序猿学社的GitHub,欢迎Star github技术专题 本文已记录到github 文章目录前言需求思路代码 前言 用过mysql的朋友,对mysql性能应该有一定的感悟,数据...使用多线程并发查询每一天的数据在合并。 代码 /** .
  • JAVA多线程处理for循环

    千次阅读 2020-12-28 14:37:01
    public static void main(String[] args) { long start = System.currentTimeMillis(); List<Integer> list = new ArrayList(); for (int i = 0;... //定义线程数量为20,可根据服务器配置适当调整大小
  • java使用多线程查询大批量数据

    万次阅读 热门讨论 2019-12-11 18:18:22
    前言 在某些时候,一旦单表数据量过大,查询数据的时候就会变得...这个查询的过程,数据量一旦过大,单线程查询数据将会成为瓶颈,下面尝试使用多线程来尝试查询一张数据量较大的表 由于代码逻辑不是很难,直接上...
  • java 多线程提高大数据量的读写效率

    千次阅读 2019-07-16 14:53:47
    对于多线程来说,刚开始是比较蒙的,不了解其中的运行机制。 最近项目中需要用多线程解决一个加载...那就要考虑下,如果将数据分批进行处理,看下哪里运行时间相对较长,将哪部分代码进行多线程处理。 注:程序员最...
  • 多线程分批处理数据

    千次阅读 2019-06-05 17:17:06
    然后使用多线程进行异步发送 步骤 1.初始化数据 2.定义每个线程分批发送大小 3.计算每个线程需要分批跑的数据 4.进行分批发送 实例: 实体类: package com.emple.entity; import java.security.SecureRa...
  • JAVA-多线程模拟处理大量数据

    千次阅读 2018-11-26 16:45:26
    此处业务场景,可想象为,有大批量的数据,需要添加到数据库 ...import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.lock...
  • Java数据量(多线程)分段分批处理

    万次阅读 热门讨论 2018-07-13 10:44:11
    package *.common.component; import java.util....import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.Execut...
  • 需求:使用多线程处理同一个List中的数据,希望每个线程处理的数量是均匀的 事例代码如下: public class Test { static class HandleThread extends Thread { private String threadName; private List&...
  • java工具类,开启线程并发处理list数据 最近在做推送相关的东西,使用umeng推送,在推送指定用户的时候,一条一条比较慢,写一个线程工具类,直接上代码 public class TencentThread extends Thread { /** * ...
  • java多线程读取、操作List集合

    千次阅读 2018-05-21 16:36:00
    /** * 固定开辟8线程 * * @Author: wpf * @Date: 16:05 2018/5/21 * @Description: * @param * @param null * @return */ private void threadExec1(List&lt;SysCompany&g...
  • 针对此问题,查阅了网上很多资料,好多都使用多线程处理。跟着好多的博客进行处理,要么是线程安全问题,要么根本速度就提高不了。我针对我项目中的使用场景,结合资料进行了修改,特提交此文,为有共同需求的小...
  • Java多线程大批量同步数据(分页)

    千次阅读 2019-09-27 11:33:52
    背景 最近遇到个功能,两个月有300w+的数据,之后还在累加,因一开始该数据就全部存储在mysql表,现需要展示在...一开始同步的时候,采用单线程,循环以分页的模式去同步这两张表数据,结果是…一晚上,只同步了30...
  • JAVA多线程10个线程处理1000个数据

    万次阅读 2018-11-06 11:02:14
    import java.util.ArrayList...import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class MultiT...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 260,090
精华内容 104,036
关键字:

java多线程处理list数据

java 订阅