详解Java多线程处理List数据

详解Java多线程处理List数据

实例1：

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

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.ArrayUtils;

public class Test_4 {

/**

* 多线程处理list

*

* @param data 数据list

* @param threadNum 线程数

*/

public synchronized void handleList(List 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;

HandleThread thread = new HandleThread("线程[" + (i + 1) + "] ", data, i * tl, end > length ? length : end);

thread.start();

}

}

class HandleThread extends Thread {

private String threadName;

private List data;

private int start;

private int end;

public HandleThread(String threadName, List data, int start, int end) {

this.threadName = threadName;

this.data = data;

this.start = start;

this.end = end;

}

public void run() {

List subList = data.subList(start, end)/*.add("^&*")*/;

System.out.println(threadName+"处理了"+subList.size()+"条！");

}

}

public static void main(String[] args) {

Test_4 test = new Test_4();

// 准备数据

List data = new ArrayList();

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

data.add("item" + i);

}

test.handleList(data, 5);

System.out.println(ArrayUtils.toString(data));

}

}

实例2：

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

//测试读取List的线程类，大概34秒

package com.thread.list;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

public class Main {

public static void main(String[] args) {

List list = new ArrayList();

Map map = new HashMap();

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

list.add(""+i);

}

int pcount = Runtime.getRuntime().availableProcessors();

long start = System.currentTimeMillis();

for(int i=0;i

Thread t = new MyThrevXdAELad1(list,map);

map.put(t.getId(),Integer.valueOf(i));

t.start();

try {

t.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

// System.out.println(list.get(i));

}

System.out.println("----"+(System.currentTimeMillis() - start));

}

}

//线程类

package com.thread.list;

import java.util.List;

import java.util.Map;

public class MyThread1 extends Thread {

private List list;

private Map map;

public MyThread1(List list,Map map){

this.list = list;

this.map = map;

}

@Override

public void run() {

int pcount = Runtime.getRuntime().availableProcessors();

int i = map.get(Thread.currentThread().getId());

for(;i

System.out.println(list.get(i));

}

}

}

实例3：

多线程分段处理List集合

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

解决方案:

List集合分段,

动态创建线程池newFixedThreadPool

将对比操作在多线程中实现

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

// 开始时间

long start = System.currentTimeMillis();

List list = new ArrayList();

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> tasks = new ArrayList>();

Callable task = null;

List 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 listStr = cutList;

task = new Callable() {

@Override

public Integer call() throws Exception {

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

return 1;

}

};

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

tasks.add(task);

}

List> results = exec.invokeAll(tasks);

for (Future future : results) {

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

}

// 关闭线程池

exec.shutdown();

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

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

}

以上所述是给大家介绍的Java多线程处理List数据详解整合，希望对大家有所帮助，如果大家有任何疑问请给我留言，会及时回复大家的。在此也非常感谢大家对我们网站的支持！

Thread t = new MyThrevXdAELad1(list,map);

map.put(t.getId(),Integer.valueOf(i));

t.start();

try {

t.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

// System.out.println(list.get(i));

}

System.out.println("----"+(System.currentTimeMillis() - start));

}

}

//线程类

package com.thread.list;

import java.util.List;

import java.util.Map;

public class MyThread1 extends Thread {

private List list;

private Map map;

public MyThread1(List list,Map map){

this.list = list;

this.map = map;

}

@Override

public void run() {

int pcount = Runtime.getRuntime().availableProcessors();

int i = map.get(Thread.currentThread().getId());

for(;i

System.out.println(list.get(i));

}

}

}

实例3：

多线程分段处理List集合

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

解决方案:

List集合分段,

动态创建线程池newFixedThreadPool

将对比操作在多线程中实现

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

// 开始时间

long start = System.currentTimeMillis();

List list = new ArrayList();

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> tasks = new ArrayList>();

Callable task = null;

List 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 listStr = cutList;

task = new Callable() {

@Override

public Integer call() throws Exception {

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

return 1;

}

};

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

tasks.add(task);

}

List> results = exec.invokeAll(tasks);

for (Future future : results) {

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

}

// 关闭线程池

exec.shutdown();

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

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

}

以上所述是给大家介绍的Java多线程处理List数据详解整合，希望对大家有所帮助，如果大家有任何疑问请给我留言，会及时回复大家的。在此也非常感谢大家对我们网站的支持！

System.out.println(list.get(i));

}

}

}

实例3：

多线程分段处理List集合

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

解决方案:

List集合分段,

动态创建线程池newFixedThreadPool

将对比操作在多线程中实现

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

// 开始时间

long start = System.currentTimeMillis();

List list = new ArrayList();

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> tasks = new ArrayList>();

Callable task = null;

List 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 listStr = cutList;

task = new Callable() {

@Override

public Integer call() throws Exception {

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

return 1;

}

};

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

tasks.add(task);

}

List> results = exec.invokeAll(tasks);

for (Future future : results) {

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

}

// 关闭线程池

exec.shutdown();

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

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

}

以上所述是给大家介绍的Java多线程处理List数据详解整合，希望对大家有所帮助，如果大家有任何疑问请给我留言，会及时回复大家的。在此也非常感谢大家对我们网站的支持！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。