Parallele und parallele Verarbeitung in verschiedenen Sprachen (Java Edition)

Machen wir in Java dasselbe wie beim letzten Mal.

long.java

public class Main {

    private static final int REPEAT = 500000000;

    private static long a = 0;

    public static void main(String[] args) throws InterruptedException{

        Thread th1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i <REPEAT; i++){
                    a = 1;
                    check();
                }
            }
        });

        Thread th2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i <REPEAT; i++){
                    a = -1;
                    check();
                }
            }
        });

        th1.start();
        th2.start();

        th1.join();
        th2.join();

        System.out.println("FINISHED!");
    }

    private static void check(){
        if(a != 1 && a != -1){
            System.out.println("LONG VALUE HAS BROKEN!");
        }
    }
}

Keine ausschließliche Kontrolle, aber es gibt einen flüchtigen Modifikator, um ein ähnliches Problem in Java zu lösen private volatile static long a = 0; Dann wird es kein Problem geben.

Volatile hat die Eigenschaft, "immer auf den neuesten Wert zu achten, wenn auf einen Wert verwiesen wird". Grob gesagt verhalten sich flüchtige Zuweisungen und Referenzen so, als wären sie gesperrt.

Aber das ist nicht sicher, deshalb benutze ich Atomic Long. Atomic: Unteilbare Operation. Dies bedeutet, dass andere bei der Ausführung einer Operation die Operation nicht unterbrechen können. private static AtomicLong a = new AtomicLong(0)

Zitat: http://d.hatena.ne.jp/cero-t/20120830/1346267076

Ein synchronisierter Block kann zur exklusiven Steuerung in Java verwendet werden.

synchronized

public class Main {

    private static final int REPEAT = 500000000;

    private static Long a = new Long(0);

    public static void main(String[] args) throws InterruptedException{

        Thread th1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i <REPEAT; i++){
                    synchronized (a){
                        a = new Long(1);
                        check();
                    }
                }
            }
        });

        Thread th2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i <REPEAT; i++){
                    synchronized (a) {
                        a = new Long(-1);
                        check();
                    }
                }
            }
        });

        th1.start();
        th2.start();

        th1.join();
        th2.join();

        System.out.println("FINISHED!");
    }

    private static void check(){
        if(a != 1 && a != -1){
            System.out.println("LONG VALUE HAS BROKEN!");
        }
    }
}

Stream # parallel kann für die parallele Verarbeitung in Java verwendet werden.

parallel

public class Main {

    public static void main(String[] args) {
	// write your code here
        IntStream.range(1,10).parallel().forEach(System.out::println);
    }
}