输入线程数量并平摊计算1-100的值

1. 我是书写了一个number类，并且定义了两个静态private 整型值max和min，并且为这两个值提供了get和set方法，之后为这个类书写了构造方法。

public class Number {
    private int max;

    private int min;

    public int getMin() {
        return min;
    }

    public void setMin(int min) {
        this.min = min;
    }

    public int getMax() {
        return max;
    }

    public void setMax(int max) {
        this.max = max;
    }
     public Number(int min,int max) {
         this.min=min;
         this.max=max;
    }
}

2.之后就是创建线程启动线程的过程。因为要输入线程数量，所以肯定要引入util包，线程使用数组存储。main方法如下：

public static void main(String[] args) {
        Number number = new Number(1, 100);
        MyThread myThread = new MyThread(number);
        System.out.println("请输入线程的数量");
        Scanner input = new Scanner(System.in);
        int num = input.nextInt();
        //储存输入值，这个需要在外面定义一个变量用来存储输入的值
        sum=num;
        Thread[] threads = new Thread[num];

     //本次new是实例化数组容器而不是里面的线程，线程还需要实例化
        for(int i=0;i<threads.length;i++)
        {

           //线程implement的runnable（）接口，防止忘记重写run（）方法
            threads[i]= new Thread(myThread,"线程"+(i+1));

       //启动线程
            threads[i].start();
        }
        
    }

3.接下来就是平摊这个操作，说实话让我困惑了一小阵子。我的逻辑大致是这样的

     1>判断输入的线程数量能否被总数目整除，若是不可，则用个变量reminder 来存储余数

     2>设置一个最小值，一个最大值，最大值为 总数目/线程数，这是一趟循环，lock锁起来，之后在sleep（）方法处理异常时在必执行的finally 当中解锁

    3>一趟循环之后，最大值呈2，最小值为上次最大值+1.这里是声明一个初始值为0变量j，在sum>1时将最大值先++j然后最大值*j

    if(sum == 1) 
            {
                maxNum = number.getMax();
            }else if(sum>1) {
                j++;
                maxNum = (number.getMax()/sum)*j;                
            }

    4>如果是奇数，在最后一趟时将最大值设为max，最小值依旧是上次最大值+1，判断方法是将j和sum比较。

       

//余数不为0
            if(reminder!=0)
            {
                for (int i = minNum; i <= maxNum; i++) {
                    cal += i;
                }
                System.out.println(Thread.currentThread().getName()+"--和为"+cal);                

                //一趟之后重新设定最小值
                if(sum>1) {
                    minNum = maxNum+1;
                    }
                //正好最后一趟
                if(j==sum) {
                    for (int i = minNum; i <= number.getMax(); i++) {
                        cal += i;
                    }
                    System.out.println(Thread.currentThread().getName()+"--和为"+cal);                                    
                }
            }

我们myThread的全部代码为：

           

package Mythread;
//输入线程数量并且平摊计算1--100的和

import java.util.Scanner;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread implements Runnable{
    private static int sum;
    private int cal=0;
    private Number number;
    
   Lock lock = new ReentrantLock();
  
    public MyThread(Number number) {
        this.number = number;
    }
    int minNum = 1;//设置下限
    int maxNum;
    int j=0;
    
    @Override
    
    public void run() {
        
            int reminder = (number.getMax()-number.getMin()+1)%sum;//求出余数        
            //余数为0
            lock.lock();
            if(sum == 1) 
            {
                maxNum = number.getMax();
            }else if(sum>1) {
                j++;
                maxNum = (number.getMax()/sum)*j;                
            }
            //刚好整除的情况
            if(reminder==0) {
                for (int i = minNum; i <= maxNum; i++) {
                    cal += i;
                }
                System.out.println(Thread.currentThread().getName()+"--和为"+cal);                

                //一趟之后重新设定最小值
                if(sum>1) {
                    minNum = maxNum+1;
                    }    
            }
            
            //余数不为0
            if(reminder!=0)
            {
                for (int i = minNum; i <= maxNum; i++) {
                    cal += i;
                }
                System.out.println(Thread.currentThread().getName()+"--和为"+cal);                

                //一趟之后重新设定最小值
                if(sum>1) {
                    minNum = maxNum+1;
                    }
                //正好最后一趟
                if(j==sum) {
                    for (int i = minNum; i <= number.getMax(); i++) {
                        cal += i;
                    }
                    System.out.println(Thread.currentThread().getName()+"--和为"+cal);                                    
                }
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
            
    public static void main(String[] args) {
        Number number = new Number(1, 100);
        MyThread myThread = new MyThread(number);
        System.out.println("请输入线程的数量");
        Scanner input = new Scanner(System.in);
        int num = input.nextInt();
        //储存输入值
        sum=num;
        Thread[] threads = new Thread[num];
        for(int i=0;i<threads.length;i++)
        {
            threads[i]= new Thread(myThread,"线程"+(i+1));
            threads[i].start();
        }
        
    }

}