10个线程同步处理1000行消息

最新推荐文章于 2023-08-31 18:09:45 发布
最新推荐文章于 2023-08-31 18:09:45 发布
阅读量688 收藏 6
点赞数 1
分类专栏： Java 文章标签： 多线程 thread J#

多线程，并发，是经常遇到的问题，平时解决的方案也想过很多，比如说现在有1000行消息，需要开10个线程同时处理。

 

之前想过两个方案：

 

方案一： 一次开10个线程，每个线程处理一条消息，等10个线程全部处理结束之后，再开启下10个线程，直到全部处理完毕

缺陷：需要等待其他n - 1个线程结束后，才能同时启动下n个线程

 

方案二： 将1000行消息分割为10份，每100行用一个线程处理。

优点：无等待

缺陷： 分割不均，无法充分利用所有的线程

 

现在想想，上面两个缺点挺多，就又想了两种方案：

 

方案三：使用ConcurrentLinkedQueue<Task>存储所有的Task，然后同时开启n个线程读取Queue.

优点：充分利用所有线程，无等待

缺点：需要将所有的task转移到Queue中，消耗一倍内存

 

方案四：使用java.util.concurrent包，固定数量线程池。

优点：完美解决

缺点：当单个task执行时间很短的时候，线程池中的线程并不会被全部使用，这样很多task就会block在一个线程中，降低执行速率

 

下面贴出每个方案的代码实现，备忘吧，如果有更好的想法，或者更简单的方式，再继续补充~

 

 

public class Task {

	private int id;
	
	public Task(int id) {
		this.id = id;
	}
	
	public void start() {
		System.out.println(Thread.currentThread().getName() + ": start to handle task " + id);

		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
}

 

 

 

import java.util.LinkedList;
import java.util.List;

public class TaskProducer {

	public static List<Task> produce(int count) {
		List<Task> tasks = new LinkedList<Task>();
		
		for(int i = 0; i < count; i ++) {
			tasks.add(new Task(i + 1));
		}
		
		return tasks;
	}
	
}

 

 

 

import java.util.LinkedList;
import java.util.List;

/**
 * 策略1: 每次开启n个线程，等待n个线程全部结束之后，再开启下n个线程，每个线程处理一个task.
 * 缺陷：需要等待其他n - 1个线程结束后，才能同时启动下n个线程
 */
public class Strategy1 {

	public static void main(String[] args) {
		List<Task> tasks = TaskProducer.produce(1000);
		handleTasks(tasks, 10);
		System.out.println("All finished");
	}
	
	public static void handleTasks(List<Task> tasks, int threadCount) {
		int taskCount = tasks.size();
		
		List<Thread> threadHolder = new LinkedList<Thread>();
		for(int i = 0; i < taskCount; i += threadCount) {
			for(int j = 0; j < threadCount && (i + j) < taskCount; j ++) {
				Thread thread = new Thread(new TaskHandler(tasks.get(i + j)));
				threadHolder.add(thread);
				thread.start();
			}
			
			waitToFinish(threadHolder);
			threadHolder.clear();
		}
	}
	
	public static void waitToFinish(List<Thread> threadHolder) {
		while(true) {
			boolean allFinished = true;
			for(Thread thread : threadHolder) {
				allFinished = allFinished && !thread.isAlive();
			}
			
			if(allFinished) {
				break;
			}
		}
	}
	
	public static class TaskHandler implements Runnable {
		private Task task;
		
		public TaskHandler(Task task) {
			this.task = task;
		}

		@Override
		public void run() {
			task.start();
		}
	}
	
}

 

 

 

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * 策略2: 将所有的task分割成n个子task列表，然后开启n个线程，每个线程处理一个子列表
 * 优点：无等待
 * 缺陷： 分割不均，无法充分利用所有的线程
 */
public class Strategy2 {

	public static void main(String[] args) {
		List<Task> tasks = TaskProducer.produce(1000);
		handleTasks(tasks, 10);
		System.out.println("All finished");
	}

	public static void handleTasks(List<Task> tasks, int threadCount) {
		List<List<Task>> splitTasks = splitTasksToNThreads(tasks, threadCount);

		List<Thread> threadHolder = new LinkedList<Thread>();
		for (List<Task> segment : splitTasks) {
			Thread thread = new Thread(new TaskHandler(segment));
			threadHolder.add(thread);
			thread.start();
		}
		
		waitToFinish(threadHolder);
	}
	
	public static void waitToFinish(List<Thread> threadHolder) {
		while(true) {
			boolean allFinished = true;
			for(Thread thread : threadHolder) {
				allFinished = allFinished && !thread.isAlive();
			}
			
			if(allFinished) {
				break;
			}
		}
	}
	
	public static List<List<Task>> splitTasksToNThreads(List<Task> tasks, int threadCount) {
		List<List<Task>> splitTasks = new ArrayList<List<Task>>(threadCount);

		int taskCount = tasks.size();
		int taskPerThread = new BigDecimal(taskCount).divide(new BigDecimal(threadCount), RoundingMode.CEILING).intValue();

		for (int i = 0; i < taskCount; i += taskPerThread) {
			List<Task> segment = new LinkedList<Task>();
			for (int j = 0; j < taskPerThread && (i + j) < taskCount; j++) {
				segment.add(tasks.get(i + j));
			}

			splitTasks.add(segment);
		}

		tasks.clear();
		
		return splitTasks;
	}
	
	public static class TaskHandler implements Runnable {
		private List<Task> tasks;

		public TaskHandler(List<Task> tasks) {
			this.tasks = tasks;
		}
		
		@Override
		public void run() {
			for (Task task : tasks) {
				task.start();
			}
		}
	}

}

 

 

 

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * 策略3: 使用ConcurrentLinkedQueue<Task>存储所有的Task，然后同时开启n个线程读取Queue.
 * 优点：充分利用所有线程，无等待
 * 缺点：需要将所有的task转移到Queue中，消耗一倍内存
 */
public class Strategy3 {

	public static void main(String[] args) {
		List<Task> tasks = TaskProducer.produce(1000);
		handleTasks(tasks, 10);
		System.out.println("All finished");
	}
	
	public static void handleTasks(List<Task> tasks, int threadCount) {
		Queue<Task> taskQueue = new ConcurrentLinkedQueue<Task>();
		taskQueue.addAll(tasks);
		
		List<Thread> threadHolder = new LinkedList<Thread>();
		for(int i = 0; i < threadCount; i ++) {
			Thread thread = new Thread(new TaskHandler(taskQueue));
			threadHolder.add(thread);
			thread.start();
		}
		
		waitToFinish(threadHolder);
	}
	
	public static void waitToFinish(List<Thread> threadHolder) {
		while(true) {
			boolean allFinished = true;
			for(Thread thread : threadHolder) {
				allFinished = allFinished && !thread.isAlive();
			}
			
			if(allFinished) {
				break;
			}
		}
	}
	
	public static class TaskHandler implements Runnable {
		
		private final Queue<Task> tasks;
		
		public TaskHandler(Queue<Task> tasks) {
			this.tasks = tasks;
		}
		
		public void run() {
			while(!tasks.isEmpty()) {
				Task task = tasks.poll();
				if(task != null) {
					task.start();
				}
			}
		}
		
	}
	
}

 

 

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * 策略4: 使用java.util.concurrent包，线程池。
 * 优点：完美解决。
 */
public class Strategy4 {

	public static void main(String[] args) {
		List<Task> tasks = TaskProducer.produce(1000);
		handleTasks(tasks, 10);
		System.out.println("All finished");
	}
	
	public static void handleTasks(List<Task> tasks, int threadCount) {
		try {
			ExecutorService executor = Executors.newFixedThreadPool(threadCount);
			
			for(Task task : tasks) {
				executor.submit(new TaskHandler(task));
			}
			
			executor.shutdown();
			executor.awaitTermination(60, TimeUnit.SECONDS);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static class TaskHandler implements Runnable {

		private Task task;
		
		public TaskHandler(Task task) {
			this.task = task;
		}
		
		public void run() {
			task.start();
		}
		
	}
	
}
iteye_9325
关注
专栏目录
并发编程处理实战篇10：线程组使用
常年被追砍的博客
08-12 186
线程组 可以把线程归属到某一个线程组中，线程组中可以有线程对象，也可以有线程对象，组中可以有线程，这样线程组可以类似树形。 线程组的使用主要是方便线程的管理维护操作： 示例 （通过线程组的方式组织多个线程并且批量停止所有线程）： 1、创建线程A和B public class ThreadA extends Thread { // 设置新的构造函数，传入线程组对象 public ThreadA(ThreadGroup group, String name) { super..
多线程（线程同步处理）
c++
02-12 139
class MyThread implements Runnable{ private int ticket = 100; public synchronized boolean sale() {//同步方法，资源 if(this.ticket>0) { try {//模拟网络延迟 Thread.sleep(100); } catch (InterruptedE...
JAVA多线程10个线程处理1000个数据
热门推荐
xiaobao5214的博客
11-06 1万+
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...
线程同步顺序执行
pengfeifei26的专栏
09-10 162
http://bianrongxin.iteye.com/blog/1356220 http://blog.csdn.net/drifterj/article/details/7771230
C#多线程及同步示例简析
01-20
二是由于对称多处理机（SMP）出现，可以满足多个运行单位，而多个进程并行开销过大。 因此在80年代，出现了能独立运行的基本单位——线程（Threads）。  线程，有时被称为轻量级进程(Lightweight Process，LWP），...
C#多线程处理多个队列数据的方法
09-03
6. **线程安全**: 示例中没有特别处理线程同步问题，这意味着在多线程环境下，队列操作可能会有竞态条件的风险。在实际应用中，可能需要使用锁定机制（如Mutex、Monitor或lock关键字）来确保线程安全，防止数据竞争...
多线程同步数据处理方法研究.pdf
08-15
【多线程同步数据处理方法研究】 在计算机科学中，多线程技术是实现并发处理的关键，它允许程序同时执行多个任务，提高了系统的效率和响应性。尤其在大数据处理和数据分析领域，多线程的应用变得越来越重要。本文将...
创建10个线程创建1.txt - 10.txt,然后创建线程11 合并到data.txt
jiashi1120的专栏
11-04 530
#include #include #include #include #include #include int counter = 0; #define MAXNUMBER 10 pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER; void *creat_file(void *arg) { char buf[
10个线程同时执行i++操作1000次，如何保证结果是1w
只为成功找方法 不为失败找借口
04-11 1590
先看代码： private static int s=0; public static void main(String[] args) throws InterruptedException { for (int j=0;j<10;j++){ Thread thread = new Thread(()->{ for (int k=0;k<1000;k++){
多线程处理List并将结果合并
kunfd的博客
02-21 4738
1.背景： 处理一个数据比较大的list（80w），并获取返回结果。发现时间比较长。打算使用多线程解决。一开始打算使用@Async 异步多线程操作。后面发现在合并操作结果的时候没有思路。 查找相关资料以后，使用了Callable和Future解决了问题。 2.相关知识点： Callable接口定义了方法public T call() throws Exception。我们可以在Callable实现中声明强类型的返回值（这个符合我们处理函数有返回值的需求），Future 用于获得 Callable .
多线程最常用的场景：单线程数据库取数，多线程处理
编程技术分享，Java后端、Vue前端
11-18 659
最好不用多线程读数据，因为读取到的数据是重复的，没有意义，还要去重，而且你没办法保证处理完的数据还会被读出来。需要考虑的就多了，完全没必要多线程读数据。如果数据有一亿，你不爆炸了，常见的就是分页了，mybatis可以用RowBounds。最常见的就是不能数据还没更新，就把源数据给删了。
多线程竞争该怎么解决？
m0_47425649的博客
07-29 1224
多线程竞争该怎么解决？ 因为线程是非独立的，同一个进程里的线程共享这个进程里的所有数据，当各个线程访问数据资源时，可能就会出现竞争状态。即： 数据几乎同时会被多个线程占用，造成数据混乱 ，即所谓的线程不安全 解决多线程竞争问题的方法就是上锁。 锁的好处：确保了某段关键代码(共享数据资源)只能由一个线程从头到尾能够完整地执行结束，它解决了多线程资源竞争下的原子操作问题。 锁的坏处：阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了 锁的致命问题：死锁 ...
多线程基础学习
05-22 538
1) 什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对 运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支 持，它也是一个很好的卖点。欲了解更多详细信息请点击这里。 2) 线程和进程有什么区...
1000条数据开10个线程处理，每次处理50条CompletableFuture 实现
最新发布
原&点、、
08-31 590
【代码】1000条数据开10个线程处理，每次处理50条CompletableFuture 实现。
提升大型网站并发访问性能
tof-j
09-02 1609
　一个小型的网站，可以使用最简单的html静态页面就实现了，配合一些图片达到美化效果，所有的页面均存放在一个目录下，这样的网站对系统架构、性能的要求都很简单。随着互联网业务的不断丰富，网站相关的技术经过这些年的发展，已经细分到很细的方方面面，尤其对于大型网站来说，所采用的技术更是涉及面非常广，从硬件到软件、编程语言、数据库、WebServer、防火墙等各个领域都有了很高的要求，已经不是原来简单的h...
大白话java多线程，高手勿入
weixin_44747933的博客
09-23 397
什么是线程说到线程我们应该先了解下什么是进程，下面这个图片大家应该都比较熟悉吧。我们看到的这些单独运行的程序就是一个独立的进程，进程之间是相互独立存在的。我们上面图中的360浏览器、百度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值