• Dieses Mal gehen wir davon aus, dass das Array mehrere Threads enthält.

Join.java

try{
    for(int i=0; i<thread.length; i++){
        thread[i].join();
    }
} catch(InterruptedException ie){
    ie.printStackTrace();
}

Unterschied zwischen mit und ohne Gewinde

Addiere 1 zur variablen Summe. Überprüfung der Ausführungszeit mit und ohne Threads für ein Programm, das dies 1000000000 Mal wiederholt.

Ohne Fäden

NoThread.java

import java.util.Date;
import java.math.BigInteger;

public class NoThread{
    private static BigInteger N = new BigInteger("1000000000");
    private static BigInteger sum = BigInteger.ZERO;

    public static void main(String[] args){
        long start_time = new Date().getTime();
        calculate();
        long end_time = new Date().getTime();
        output(start_time, end_time);
    }

    public static void calculate(){
        BigInteger i = BigInteger.ZERO;
        while(!i.equals(N)){
            sum = sum.add(BigInteger.ONE);   // sum += i
            i = i.add(BigInteger.ONE);       // i++
        }
    }

    public static void output(long s, long e){
        System.out.println("Sum: "+sum);
        System.out.println("total time: "+(e-s)+"ms");
    }
}

Ausführungsergebnis:

• Die Bearbeitungszeit ist nicht immer konstant.

Wenn es einen Thread gibt

Geben Sie dieses Mal die Anzahl der Threads im Argument zur Laufzeit an.

ThreadRun.java

import java.math.BigInteger;
import java.util.Date;

public class ThreadRun{
    private static BigInteger N = new BigInteger("1000000000");
    private static BigInteger sum = BigInteger.ZERO;

    public static void main(String[] args){
        int num_threads = Integer.parseInt(args[0]);
        BigInteger range = N.divide(new BigInteger(args[0]));

        ThreadRunnable[] tr = new ThreadRunnable[num_threads];
        Thread[] t = new Thread[num_threads];

        BigInteger low = BigInteger.ONE;
        BigInteger high = low.add(range);
        long start_time = new Date().getTime();

        for(int i=0; i<num_threads-1; i++){
            tr[i] = new ThreadRunnable(low, high);
            t[i] = new Thread(tr[i]);
            t[i].start();

            low = high.add(BigInteger.ONE);
            high = low.add(range);
        }
        tr[num_threads-1] = new ThreadRunnable(low, high);
        t[num_threads-1] = new Thread(tr[num_threads-1]);
        t[num_threads-1].start();

        try{ // check whether threads finished
            for(int i=0; i<num_threads; i++){
                t[i].join();
            }
        } catch(InterruptedException ie){
            ie.printStackTrace();
        }

        for(int i=0; i<num_threads; i++){
            sum = sum.add(tr[i].getSum());
        }
        
        long end_time = new Date().getTime();
        System.out.println("Sum: "+sum);
        System.out.println("total time: "+(end_time-start_time)+"ms");
    }

    protected static class ThreadRunnable implements Runnable{
        private BigInteger sum_temp;
        private BigInteger low, high;
        public ThreadRunnable(BigInteger l, BigInteger h){
            this.low = l;
            this.high = h;
            this.sum_temp = BigInteger.ZERO;
        }

        @Override
        public void run(){
            while(!low.equals(high)){
                sum_temp = sum_temp.add(BigInteger.ONE);  // sum_temp += low
                low = low.add(BigInteger.ONE); // low++;
            }
        }

        public BigInteger getSum(){
            return sum_temp;
        }
    }
}

Ausführungsergebnis: Wenn es einen Thread gibt,

• Die Bearbeitungszeit ist nicht immer konstant.

Zusammenfassung

Die Verarbeitungszeit ist mit Threads kürzer als ohne Threads. Die effektive Verwendung von Threads kann viel Zeit sparen. Wenn Sie jedoch die Anzahl der Threads zu stark erhöhen, erhöht sich die Ausführungszeit. Daher ist es wichtig, eine geeignete Anzahl von Threads </ font> anzugeben.