多线程计算数据,然后合并数据

假设有一个计算量非常大的任务,使用单线程处理会花费很长时间才能处理完成,这时候可以考虑使用多线程分批计算数据,然后再汇总数据输出。在这里,使用了CyclicBarrier来实现。这个类的功能就是指定特定的线程数,等到这些线程都执行完毕之后,才会执行它的await()方法后面的代码,如果在构造器里设定了一个线程类,那么会在业务线程执行完毕之后,先执行构造器里的线程,然后执行await方法后面的线程。



package test;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.Callable;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test1 {

	private static ExecutorService service = Executors.newFixedThreadPool(4);
	
	public static void main(String[] args) {
		
		final Map<String, Integer> map = new HashMap<String, Integer>(4);
		
		CyclicBarrier cb = new CyclicBarrier(4, new Runnable(){
			public void run() {
				Integer count1 = map.get("1");
				Integer count2 = map.get("2");
				Integer count3 = map.get("3");
				Integer count4 = map.get("4");
				System.out.println("count= " + (count1 + count2 + count3 + count4));
			}
		});
		new Thread(new TestThread(map, "1", cb,1000)).start();
		new Thread(new TestThread(map, "2", cb,1000)).start();
		new Thread(new TestThread(map, "3", cb,1000)).start();
		new Thread(new TestThread(map, "4", cb,1000)).start();
		
		//线程池实现方式
		int sum = 0;
		for(int i = 0; i < 4; i++) {
			Future<Integer> data = service.submit(new Callable<Integer>(){
	
				@Override
				public Integer call() throws Exception {
					int sum = 0;
					for(int i = 0; i < 1000; i++) {
						sum += i;
					}
					return sum;
				}
				
			});
			try {
				sum += data.get().intValue();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("count===" + sum);
	}

}

class TestThread implements Runnable {

	private Map<String, Integer> map;
	private String type;
	private CyclicBarrier cb;
	private int n;
	public TestThread(Map<String, Integer> map, String type, CyclicBarrier cb, int n) {
		this.map = map;
		this.type =type;
		this.cb = cb;
		this.n = n;
	}
	
	@Override
	public void run() {
		int sum = 0;
		for(int i = 0; i < n; i++) {
			sum += i;
		}
		map.put(type, sum);
		try {
			cb.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	
	}
	
}


### 回答1: Python 中可以使用 queue 模块中的 Queue 类来在多线程之间传递数据。主线程可以不断地从队列中读取数据并进行合并。 例如: ```python from queue import Queue from threading import Thread def worker(): while True: item = q.get() # do_work(item) q.task_done() q = Queue() for i in range(num_worker_threads): t = Thread(target=worker) t.daemon = True t.start() for item in source(): q.put(item) q.join() # block until all tasks are done ``` 在这个例子中,主线程会启动多个 worker 线程,并将数据放入队列中,worker 线程会不断地从队列中读取数据进行处理。当队列中的所有数据都被处理完后,主线程会调用 q.join() 方法阻塞等待所有 worker 线程处理完成。 ### 回答2: 在Python中,我们可以通过使用多线程来同时处理多个任务,但是由于多线程的并发执行性质,不同线程执行的结果可能是分散的。因此,当我们需要合并多线程运行后的数据时,可以采取以下几种方式。 一种常用的方式是使用队列(Queue)来存储线程的运行结果。我们可以创建一个共享的队列对象,并将每个线程的运行结果放入队列中。在主线程中,可以通过从队列中逐个取出结果,并进行合并操作。这种方式可以保证线程运行的结果有序且不会被混淆。 另一种方式是使用线程锁(Lock)来保证线程的同步执行。我们可以在主线程中创建一个共享的数据对象,并对该对象设置一个线程锁。在每个线程中执行运算后,需要先获得线程锁才能访问并修改共享数据对象。这样可以保证在任意时刻只有一个线程能够修改数据,从而避免数据的竞争和混乱。 此外,我们还可以使用线程池来管理和控制多个线程的执行。通过创建一个线程池对象,并调用其内部的线程方法,可以并发地执行多个线程任务。在每个线程任务中,我们可以将结果保存到一个共享的数据对象中。最后,在主线程合并这些结果并进行进一步的处理。 总之,Python提供了多种处理多线程运行后数据合并的方式,包括使用队列、线程锁和线程池等。根据具体的需求和场景,我们可以选择适合的方式来实现多线程任务的合并处理。 ### 回答3: Python提供了多种方法将多线程运行后的数据进行合并。 一种常见的方法是使用线程锁,即使用`threading.Lock`类来保护共享数据。在每个子线程运行结束后,可以使用线程锁来确保在合并数据时不会同时进行写操作,从而避免数据冲突。具体步骤如下: 1. 导入`threading`模块,创建一个线程锁对象:`lock = threading.Lock()` 2. 在每个子线程中,在需要修改共享数据之前,获取线程锁:`lock.acquire()` 3. 在修改共享数据完成后,释放线程锁:`lock.release()` 4. 在主线程中,通过获取线程锁,合并所有子线程运行后的数据 示例代码如下: ```python import threading # 共享数据 shared_data = [] # 线程锁 lock = threading.Lock() # 子线程函数 def thread_function(): global shared_data # 假设在这里进行了某些耗时的操作,比如计算 result = some_calculation() # 获取线程锁 lock.acquire() # 修改共享数据 shared_data.append(result) # 释放线程锁 lock.release() def main(): # 创建并启动所有子线程 threads = [] for i in range(10): thread = threading.Thread(target=thread_function) threads.append(thread) thread.start() # 等待所有子线程运行结束 for thread in threads: thread.join() # 合并所有子线程运行后的数据 merged_data = [] for data in shared_data: merged_data.extend(data) # 输出合并后的数据 print(merged_data) ``` 除了使用线程锁,还可以使用其他同步机制,比如`threading.Event`、`threading.Condition`等,根据具体情况选择合适的方法来合并多线程运行后的数据
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值