Многопоточность java прогрессия [закрыт]

115

24 октября 2019, 00:20

Найти сумму арифметической прогрессии f(n, N) = n + 2n + 3n + 4n + 5n + ... + Nn, n=4 N - достаточно большое число, что бы посчитать результат на протяжении нескольких секунд.

1) С помощью оператора цикла, который работает в одном треде 2) С помощью оператора цикла, который работает в нескольких тредах (2,4,8,16,32)

Так же сравнить скорость выполнения для работы с несколькими тредами. Помогите разобраться, пожалуйста.

class two extends Thread {
public void run() {
    long t1 = System.currentTimeMillis();
    for (int n = 0; n <= 5000; n++) {
        long t2 = System.currentTimeMillis();
        int a1 = 4;
        int d = 4;
        System.out.println(t2-t1 + "милисекунд");

            int S = ((2 * a1 + d * (n - 1)) * n) / 2;
            System.out.println(S);
        }
    }
}
    public class three  //Класс с методом main()
{
    static two mAnotherSide;    //Побочный поток
public static void main(String[] args) {
    mAnotherSide = new two();
    System.out.println("Счет начат");
    mAnotherSide.start();
    long t1 = System.currentTimeMillis();
    for (int n = 5001; n < 10000; n++) {
        long t2 = System.currentTimeMillis();
        System.out.println(t2 - t1 + "милисекунд");
        int a1 = 4;
        int d = 4;
        int S = ((2 * a1 + d * (n - 1)) * n) / 2;
        System.out.println(S);
    }
}
}

Answer 1

Можно так

public class ArithmeticProgress {
    public static void main(String[]args){
        ArithmeticProgress ap = new ArithmeticProgress();
        ap.calc();
    }
    private void calc(){
        int [] arrThreadsCounts = {1,2,4,8,16,32};
        long timeStart =0L;
        for(int thCount : arrThreadsCounts) {
            timeStart = System.currentTimeMillis();
            long res = calculateArithmeticProgress(2, 6400, thCount);
            System.out.println("Результат: " + res +
                    " кол-во потоков " + thCount +
                            " расчитан за " + (System.currentTimeMillis()-timeStart) + " мс"
                    );
        }
    }
    /**
     * Запускает потоки и подсчитывает итоговый результат вычисления
     * @param x число для которого расчитываем арифметическую прогрессию
     * @param n максимальный множитель прогрессии
     * @param threadsCount колличество потоков в которых
     *                     считать арифметическую прогрессию
     */
    private long calculateArithmeticProgress(int x, int n, int threadsCount){
        long res = 0;
        int nMax = 0;
        int nMin = 0;
        //кол-во множителей для одного потока
        int m = n/threadsCount;
        //если число n нацело не делится на кол-во потоков
        //то в последний поток добавляем остаток от деления
        int mLast = n/threadsCount + n%threadsCount;
        //в этом списке храним все запускаемые потоки
        List<ArithmeticThread> threads = new ArrayList<>(threadsCount);

        //запускаем потоки
        ArithmeticThread at;
        for(int i = 0;i<threadsCount;i++){
            nMin = nMax + 1;
            nMax = (nMin - 1) + (i==threadsCount-1 ? mLast : m);
            at = new ArithmeticThread(x,nMin,nMax);
            threads.add( at );
            at.start();
        }
        // Мониторим окончание работы потоков и
        // суммируем итоговый результат
        for(ArithmeticThread t : threads){
            try {
                t.join();
                res+=t.result;
                //System.out.println("Монитор: " + t.getName() + " result " + res);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return res;
    }

    /**
     * Поток расчитывает часть арифметичаской прогрессии
     * для числа x c множителя nMin до nMax
     */
    private class ArithmeticThread extends Thread{
        int x;
        int nMin;
        int nMax;
        long result;
        /**
         * Поток расчитывает часть арифметичаской прогрессии
         * для числа x c множителя nMin до nMax
         * @param x число для которого расчитываем арифметическую прогрессию
         * @param nMin минимальное значение n расчитываемое в потоке
         * @param nMax максимальное значение n расчитываемое в потоке
         */
        public ArithmeticThread(int x, int nMin, int nMax ) {
            setName("Thread_"+nMin+"_"+nMax);
            //System.out.println(getName() + " cоздание потока");
            this.x = x;
            this.nMin = nMin;
            this.nMax = nMax;
        }
        @Override
        public void run() {
            long res=0;
            for(int i = nMin; i <= nMax; i++){
                res += x*i;
            }
            result = res;
            //System.out.println(getName() + " получен результат: " + result);
        }
        /**
         * Возвращает результат расчета
         * @return результат
         */
        public long getResult() {
            return result;
        }
    }
}