计算很大数组中List的和

最新推荐文章于 2022-10-27 17:29:32 发布

kgr957

最新推荐文章于 2022-10-27 17:29:32 发布

阅读量121

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java thread 多线程

本文链接：https://blog.youkuaiyun.com/jqsl2012/article/details/84042013

java 专栏收录该内容

21 篇文章

订阅专栏

本文介绍了一种使用多线程和并行计算优化数组求和的方法，通过将任务分解到多个线程中，提高了计算效率。详细阐述了如何利用并发编程技术，如CyclicBarrier和ConcurrentLinkedQueue，实现并行处理和结果聚合。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

原帖地址：
[url]http://www.iteye.com/topic/711162[/url]


package thread;

import java.util.Iterator;
import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CyclicBarrier;

public class SegmentCount {
	public static void main(String[] args) {
		int[] arr = new int[10123];
		Random ran = new Random();
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			arr[i] = ran.nextInt(10000);
			sum += arr[i];
		}
		System.out.println("结果应该为：" + sum);

		// 多线程进行数组拆分计算
		int threadSize = 10;
		int avg = arr.length / threadSize;// 平均任务数
		int surplus = arr.length % threadSize;// 剩余任务数
		threadSize = surplus > 0 ? (++threadSize) : threadSize;
		final ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<Integer>();// 结果队列
		CyclicBarrier barrier = new CyclicBarrier(threadSize, new Runnable() {
			public void run() {
				System.out.println("统计:");
				System.out.println(queue);
				int sum = 0;
				Iterator<Integer> it = queue.iterator();
				while (it.hasNext()) {
					sum += Integer.valueOf(it.next().toString());
				}
				System.out.println("sum:" + sum);
			}
		});

		for (int i = 1; i <= threadSize; i++) {
			int end = i * avg;
			end = (end > arr.length) ? arr.length : end;
			new Thread(new Segment(barrier, arr, (i - 1) * avg, end, queue))
					.start();
		}
	}
}

class Segment implements Runnable {
	CyclicBarrier barrier;
	int[] arr;
	int start;
	int end;
	ConcurrentLinkedQueue<Integer> queue;

	public Segment(CyclicBarrier barrier, int[] arr, int start, int end,
			ConcurrentLinkedQueue<Integer> queue) {
		super();
		this.barrier = barrier;
		this.arr = arr;
		this.start = start;
		this.end = end;
		this.queue = queue;
	}

	int sum = 0;

	public void run() {
		System.out.println(Thread.currentThread().getName() + ",start:" + start
				+ ",end:" + end);
		for (int i = start; i < end; i++) {
			sum += arr[i];
		}
		queue.offer(sum);
		try {
			barrier.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			e.printStackTrace();
		}
	}
}


package thread;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class SegmentCount2 {
	public static void main(String[] args) throws InterruptedException,
			ExecutionException {
		int[] arr = new int[10123];
		Random ran = new Random();
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			arr[i] = ran.nextInt(10000);
			sum += arr[i];
		}
		System.out.println("结果应该为：" + sum);

		// 多线程进行数组拆分计算

		int threadSize = 10;
		int avg = arr.length / threadSize;// 平均任务数
		int surplus = arr.length % threadSize;// 剩余任务数
		threadSize = surplus > 0 ? (++threadSize) : threadSize;

		ExecutorService pool = Executors.newCachedThreadPool();
		List<Segment2> tasks = new ArrayList<Segment2>();
		for (int i = 1; i <= threadSize; i++) {
			int end = i * avg;
			end = (end > arr.length) ? arr.length : end;
			tasks.add(new Segment2(arr, (i - 1) * avg, end));
		}
		// 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。
		List<Future<Integer>> result = pool.invokeAll(tasks);

		int summ = 0;
		for (int i = 0; i < result.size(); i++) {
			FutureTask<Integer> task = (FutureTask<Integer>) result.get(i);
			summ += Integer.valueOf(task.get().toString());
		}
		System.out.println("总共：" + summ);
		pool.shutdown();
	}
}

class Segment2 implements Callable<Integer> {
	int[] arr;
	int start;
	int end;

	public Segment2(int[] arr, int start, int end) {
		super();
		this.arr = arr;
		this.start = start;
		this.end = end;
	}

	int sum = 0;

	public Integer call() throws Exception {
		System.out.println(Thread.currentThread().getName() + ",start:" + start
				+ ",end:" + end);
		for (int i = start; i < end; i++) {
			sum += arr[i];
		}
		return sum;
	}
}


package thread;

import java.util.Iterator;
import java.util.Random;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;

public class SegmentCount3 {
	public static void main(String[] args) throws InterruptedException,
			ExecutionException {
		int[] arr = new int[10123];
		Random ran = new Random();
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			arr[i] = ran.nextInt(10000);
			sum += arr[i];
		}
		System.out.println("结果应该为：" + sum);

		// 多线程进行数组拆分计算

		int threadSize = 10;
		int avg = arr.length / threadSize;// 平均任务数
		int surplus = arr.length % threadSize;// 剩余任务数
		threadSize = surplus > 0 ? (++threadSize) : threadSize;
		final ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<Integer>();// 结果队列
		CountDownLatch beginSignal = new CountDownLatch(1);
		CountDownLatch endSignal = new CountDownLatch(threadSize);

		for (int i = 1; i <= threadSize; i++) {
			int end = i * avg;
			end = (end > arr.length) ? arr.length : end;
			new Thread(new Segment3(beginSignal, endSignal, arr, (i - 1) * avg,
					end, queue)).start();
		}
		System.out.println("开闸");
		beginSignal.countDown();
		endSignal.await();
		System.out.println("统计：" + queue);
		Iterator<Integer> it = queue.iterator();
		int summ = 0;
		while (it.hasNext()) {
			summ += it.next();
		}
		System.out.println(summ);
	}
}

class Segment3 implements Runnable {
	CountDownLatch beginSignal;
	CountDownLatch endSignal;
	int[] arr;
	int start;
	int end;
	ConcurrentLinkedQueue<Integer> queue;

	public Segment3(CountDownLatch beginSignal, CountDownLatch endSignal,
			int[] arr, int start, int end, ConcurrentLinkedQueue<Integer> queue) {
		super();
		this.beginSignal = beginSignal;
		this.endSignal = endSignal;
		this.arr = arr;
		this.start = start;
		this.end = end;
		this.queue = queue;
	}

	int sum = 0;

	public void run() {
		try {
			beginSignal.await();

			System.out.println(Thread.currentThread().getName() + ",start:"
					+ start + ",end:" + end);

			for (int i = start; i < end; i++) {
				sum += arr[i];
			}
			queue.offer(sum);
			endSignal.countDown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}