Java多线程求和实例讲解

Java 多线程在并发编程中扮演重要的角色。在自己项目或者框架中常常需要多线程来加速程序的运行。今天我们通过一个简单的例子来详细讲解 Java 多线程的使用方法。

本文将介绍使用 Java 多线程实现一个简单的求和程序，可以用于协助理解多线程的基础使用方法。本文讲解的 Java 多线程求和实例包含以下内容：

1. 需求描述

2. 实现步骤

3. 源码解析

4. 总结

## 1. 需求描述

我们希望实现一个多线程求和程序，可以输入一个整数 n，然后使用多线程计算出 1 到 n 的和。

## 2. 实现步骤

1. 构建主程序入口，定义一个静态内部类 SumThread，用于实现多线程任务。

2. 在 SumThread 内部定义一个从 start 到 end 累加的静态方法 sum()，线程启动后调用该方法计算结果。

3. 主程序通过 Scanner 读取一个整数 n，并将 n 分为多个线程分别计算部分和。

4. 每个线程计算出它需要计算的部分和后，把部分和返回并存储在一个结果数组中。

5. 最终，主程序将结果数组中所有元素相加得到最终结果，并输出计算机运算完成时间。

## 3. 源码解析

下面是 Java 多线程求和程序的源代码：

import java.util.Scanner;
import java.util.concurrent.TimeUnit;

public class MainThread {

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入一个整数n：");
        int input=scanner.nextInt();
        long startTime=System.currentTimeMillis();
        int numThread=5;// 线程数量
        int[] results=new int[numThread];// 存放每个线程的部分和结果
        int endIndex;
        int startIndex=1;
        SumThread[] threads=new SumThread[numThread];// 存放线程的数组
        for (int i=0;i<numThread;i++) {
            endIndex=startIndex+input/numThread-1;
            if (i==numThread-1) {
                endIndex=input;
            }
            threads[i]=new SumThread(startIndex,endIndex);// 创建线程
            threads[i].start();// 启动线程
            startIndex=endIndex+1;
        }
        int sum=0;
        for (int i=0;i<numThread;i++) {
            try {
                threads[i].join();// 等待线程结束
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            results[i]=threads[i].getResult();// 获得线程计算的结果
        }
        for (int i=0;i<numThread;i++) {// 将所有线程的结果汇总起来
            sum+=results[i];
        }
        System.out.println("1加到"+input+"的和为："+sum);
        long duration=System.currentTimeMillis()-startTime;
        System.out.println("用时："+TimeUnit.MILLISECONDS.toSeconds(duration)+" 秒");
    }
    
    static class SumThread extends Thread {
        private int start,end,result;
        
        public SumThread(int start,int end) {
            this.start=start;
            this.end=end;
        }
        
        public int getResult() {
            return result;
        }

        public void run() {
            result=sum(start,end);// 计算部分和
        }
        
        public static int sum(int start,int end) {
            int sum=0;
            for (int i=start;i<=end;i++) {
                sum+=i;
            }
            return sum;
        }
    }
}

主函数中首先通过 Scanner 读取一个整数 n，然后启动 numThread 个线程计算部分和。每个线程设定startIndex 和 endIndex，startIndex 的初始值为 1，endIndex 初始值为 input / numThread - 1，在创建每个线程之前累加 startIndex 和 endIndex。最后一个线程的 endIndex 等于 input。

每个 SumThread 类实质上代表一个线程，通过实现 run() 方法来执行多线程任务。我们定义一个静态方法 sum() 来计算某个线程需要计算的部分和，用 result 变量保存计算结果，并在 getResult() 方法中返回结果。

主线程中监控所有子线程是否执行结束，即所有线程都调用了 join() 方法。如果线程结束的时候，它的结果会被存储在 result[] 数组中。最后，我们将所有元素相加得到最终结果，并输出计算时间。

## 4. 总结

Java 多线程提供了一种实现并发编程的方法，可以在提高程序效率同时简化编程。在本文中，我们通过一个简单的例子详细讲解了 Java 多线程的使用和实现方法，并给出了完整的 Java 源代码。阅读本文后，相信你已经对 Java 多线程有了更深入的了解。