Traitement parallèle et parallèle dans divers langages (édition Java)

Faisons la même chose en Java que la dernière fois.

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!");
        }
    }
}

Pas de contrôle exclusif, mais il existe un modificateur volatil pour résoudre un problème similaire en Java private volatile static long a = 0; Il n'y aura alors aucun problème.

Volatile a la propriété de "toujours regarder la dernière valeur lors du référencement d'une valeur". En gros, les affectations et références volatiles se comportent comme si elles étaient verrouillées.

Mais ce n'est pas sûr, j'utilise donc Atomic Long. Atomique: opération indivisible. Cela signifie que lors de l'exécution d'une opération, les autres ne peuvent pas interrompre l'opération. private static AtomicLong a = new AtomicLong(0)

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

Un bloc synchronisé peut être utilisé pour un contrôle exclusif en Java.

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 peut être utilisé pour le traitement parallèle en Java.

parallel

public class Main {

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