java 一个包含了2万个整数的数组,多线程来进行并行计算

一个包含了2万个整数的数组

计算任务:一个包含了2万个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。

数据错误的原因：4个子线程还没有执行完毕，主线程就抢到资源并输出结果
解决方案：4个子线程全部执行完毕，再让主线程抢到资源
1.休眠
Thread.sleep(10);
2.获取线程状态
while(t1.isFlag() || t2.isFlag() || t3.isFlag() || t4.isFlag()){
}
3.合并

​ t1.join();
​ t2.join();

第一种解决方案：Thread接口实现

package com.dream.work01;
public class Work {
	
	public static void main(String[] args) throws InterruptedException {
		/**
		 * 计算任务，一个包含了2万个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。
		 */
		//声明包含2万个整数的数组
		int[] is = new int[20000];
		//初始化数据
		for (int i = 0; i < is.length; i++) {
			is[i] = (i+1);
		}
		MyThread t1 = new MyThread(0, 4999, is);
		MyThread t2 = new MyThread(5000, 9999, is);
		MyThread t3 = new MyThread(10000, 14999, is);
		MyThread t4 = new MyThread(15000, 19999, is);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		//数据错误的原因：4个子线程还没有执行完毕，主线程就抢到资源并输出结果
		//解决方案：4个子线程全部执行完毕，再让主线程抢到资源
		//1.休眠
		//Thread.sleep(10);
		//2.获取线程状态
		//while(t1.isFlag() || t2.isFlag() || t3.isFlag() || t4.isFlag()){
		//}
		//3.合并
		t1.join();
		t2.join();
		t3.join();
		t4.join();
		System.out.println(t1.getSum() + t2.getSum() + t3.getSum() + t4.getSum());
	}
}
class MyThread extends Thread{
	private int startIndex;
	private int endIndex;
	private int[] is;
	private int sum;
	private boolean flag = true;
	public MyThread(int startIndex, int endIndex, int[] is) {
		this.startIndex = startIndex;
		this.endIndex = endIndex;
		this.is = is;
	}
	@Override
	public void run() {
		for (int i = startIndex; i <= endIndex; i++) {
			sum += is[i];
		}
		flag = false;
	}
	public int getSum() {
		return sum;
	}
	public boolean isFlag() {
		return flag;
	}
}

第二种解决方案：Runnable接口实现

public class Work {
	public static void main(String[] args) throws InterruptedException {
		//声明包含2万个整数的数组
		int[] is = new int[20000];
		//初始化数据
		for (int i = 0; i < is.length; i++) {
			is[i] = (i+1);
		}
		Task task1 = new Task(0, 4999, is);
		Task task2 = new Task(5000, 9999, is);
		Task task3 = new Task(10000, 14999, is);
		Task task4 = new Task(15000, 19999, is);
		Thread t1 = new Thread(task1);
		Thread t2 = new Thread(task2);
		Thread t3 = new Thread(task3);
		Thread t4 = new Thread(task4);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t1.join();
		t2.join();
		t3.join();
		t4.join();
		System.out.println(task1.getSum() + task2.getSum() + task3.getSum() + task4.getSum());
	}
}
class Task implements Runnable{
	
	private int startIndex;
	private int endIndex;
	private int[] is;
	private int sum;
	private boolean flag = true;
	public Task(int startIndex, int endIndex, int[] is) {
		this.startIndex = startIndex;
		this.endIndex = endIndex;
		this.is = is;
	}
	@Override
	public void run() {
		for (int i = startIndex; i <= endIndex; i++) {
			sum += is[i];
		}
		flag = false;
	}
	public int getSum() {
		return sum;
	}
	public boolean isFlag() {
		return flag;
	}
}