Java Multithreading - Thread-Safe Compteur

Les deux fils ont accès à votre variable.

Le phénomène que vous voyez est appelé de threads. À l'entrée de la gardé partie de votre code (désolé, j'ai manqué plus tôt), les autres threads aurez besoin de bloquer jusqu'à ce que le thread en tenant le moniteur est fait (c'est à dire lorsque le moniteur est publié). Si l'on peut s'attendre à le thread courant passer le moniteur à l'autre thread en attente dans la ligne, pour la synchronisation de blocs, java ne garantit pas l'équité ou de la politique de commande pour le thread suivant reçoit le moniteur. Il est tout à fait possible (et même probable) pour un thread qui libère et tente d'acquérir le moniteur pour obtenir de celui-ci sur un autre thread qui a été en attente pendant un certain temps.

À Partir D'Oracle:

La famine décrit une situation où un thread est dans l'impossibilité d'obtenir un accès régulier aux ressources partagées et est incapable de faire des progrès. Cela se produit lorsque les ressources partagées sont rendus indisponibles pendant de longues périodes par "gourmand" threads. Par exemple, supposons qu'un objet fournit une méthode synchronisée qui prend souvent un long temps de retour. Si un thread appelle cette méthode fréquemment, les autres threads qui ont également besoin de fréquents accès synchronisé sur le même objet sera souvent bloqué.

Tandis que les deux threads sont des exemples de "gourmand" threads (depuis ils ne cessent de libérer et de réacquérir le moniteur), thread-0 est techniquement a commencé le premier, donc d'en priver thread-1.

La solution est d'utiliser en même temps une méthode de synchronisation qui prend en charge l'équité (par exemple, ReentrantLock) comme indiqué ci-dessous:

public class ThreadsExample implements Runnable {
    static int counter = 1; //a global counter

    static ReentrantLock counterLock = new ReentrantLock(true); //enable fairness policy

    static void incrementCounter(){
        counterLock.lock();

        //Always good practice to enclose locks in a try-finally block
        try{
            System.out.println(Thread.currentThread().getName() + ": " + counter);
            counter++;
        }finally{
             counterLock.unlock();
        }
     }

    @Override
    public void run() {
        while(counter<1000){
            incrementCounter();
        }
    }

    public static void main(String[] args) {
        ThreadsExample te = new ThreadsExample();
        Thread thread1 = new Thread(te);
        Thread thread2 = new Thread(te);

        thread1.start();
        thread2.start();          
    }
}

remarque la suppression de l' synchronized mot-clé en faveur de la ReentrantLock dans la méthode. Un tel système, avec un surveillant de l'équité de la politique, permet de longues threads en attente d'une chance de s'exécuter, la suppression de la faim.

OriginalL'auteur initramfs

Bien, avec ton code, je ne sais pas comment l'avoir "exactement" par intermittence, mais si vous utilisez Thread.yield() après appel incrementCounter() vous aurez une meilleure distribution.

public void run() {
         while(counter<1000){
              incrementCounter();
              Thread.yield();

         }
    }

Sinon, pour ce que vous proposez, vous pouvez créer deux classe thread (ThreadsExample1 et ThreadsExample2 si vous voulez), et une autre classe pour une variable partagée.

public class SharedVariable {
    private int value;
    private boolean turn; //false = ThreadsExample1 --> true = ThreadsExample2

    public SharedVariable (){
        this.value = 0;
        this.turn = false;
    }

    public void set (int v){
        this.value = v;
    }

    public int get (){
        return this.value;
    }

    public void inc (){
        this.value++;
    }

    public void shiftTurn(){
        if (this.turn){
            this.turn=false;
        }else{
            this.turn=true;
        }
    }

    public boolean getTurn(){
        return this.turn;
    }

}

Maintenant, la principale peut être:

public static void main(String[] args) {
        SharedVariable vCom = new SharedVariable();
        ThreadsExample1 hThread1 = new ThreadsExample1 (vCom);
        ThreadsExample2 hThread2 = new ThreadsExample2 (vCom);

        hThread1.start();
        hThread2.start();

        try {
            hThread1.join();
            hThread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

Et vous devez changer votre ligne de static int counter = 1; //a global counter
pour private SharedVariable counter;

Et la nouvelle exécution est:

public void run() {
    for (int i = 0; i < 20; i++) {
        while (!counter.getTurno()){
            Thread.yield();
        }
        System.out.println(this.counter.get());
        this.counter.cambioTurno();
    }
}

}

Oui, c'est un autre code, mais je pense que ça peut vous aider un peu.

OriginalL'auteur Shondeslitch