Qu'est ce qu'une condition?

Une condition de concurrence se produit lorsque deux ou plusieurs threads peuvent accéder à des données partagées et ils essaient de le changer en même temps. Parce que le fil algorithme d'ordonnancement pouvez permuter entre les threads, à tout moment, vous ne savez pas l'ordre dans lequel les threads tentent d'accéder aux données partagées. Par conséquent, le résultat de la variation des données est dépendante sur le thread de l'algorithme d'ordonnancement, c'est à dire les deux fils sont "racing" pour accéder/modifier le données.

Problèmes surviennent souvent lorsqu'un thread fait un "check-puis-loi" (par exemple "vérifier" si la valeur est X, alors la "loi" de faire quelque chose qui dépend de la valeur de X) et un autre thread fait quelque chose pour la valeur entre le "check" et la "loi". E. g:

if (x == 5) //The "Check"
{
   y = x * 2; //The "Act"

   //If another thread changed x in between "if (x == 5)" and "y = x * 2" above,
   //y will not be equal to 10.
}

Le point de l'être, y pourrait être de 10, ou il pourrait être n'importe quoi, selon qu'un autre thread changé x entre le chèque et la loi. Vous n'avez pas de véritable moyen de savoir.

Afin de prévenir les conditions de compétition, que vous auriez normalement mettre un verrou autour de données partagées pour s'assurer qu'un seul thread peut accéder aux données à la fois. Cela signifierait quelque chose comme ceci:

//Obtain lock for x
if (x == 5)
{
   y = x * 2; //Now, nothing can change x until the lock is released. 
              //Therefore y = 10
}
//release lock for x

Ce qui est une Condition de concurrence?

Vous envisagez d'aller voir un film à 5 pm. Vous vous renseigner sur la disponibilité des billets à 4 pm. Le représentant a dit qu'ils sont disponibles. De vous détendre et d'atteindre le guichet 5 minutes avant le spectacle. Je suis sûr que vous pouvez deviner ce qui se passe: c'est un full house. Le problème, c'est dans la durée entre la vérification et de l'action. Vous m'avez demandé à 4 et a agi à 5. En attendant, quelqu'un d'autre a attrapé les billets. C'est une condition de concurrence - en particulier un "check-puis-loi" scénario de conditions de course.

Comment les détecter?

Religieux de la revue de code, multi-thread tests unitaires. Il n'y a pas de raccourci. Il y a quelques plugin Eclipse qui apparaissent sur le présent, mais rien de stable encore.

Comment gérer et prévenir?

La meilleure chose serait de créer sans effets secondaires et apatrides fonctions, utiliser immutables autant que possible. Mais ce n'est pas toujours possible. Donc, à l'aide de java.util.de façon concomitante.atomique, simultanés des structures de données, la synchronisation, et l'acteur en fonction de la simultanéité de l'aide.

La meilleure ressource pour la simultanéité est JCIP. Vous pouvez également obtenir de plus des détails sur l'explication ci-dessus ici.

Une sorte de définition canonique est "lorsque deux threads accèdent à la même emplacement en mémoire en même temps, et au moins l'un des accès est une écriture." Dans la situation que le "lecteur" thread peut obtenir la valeur ancienne ou la nouvelle valeur, en fonction sur le thread "gagne la course." Ce n'est pas toujours un bug en fait, certains vraiment poilu bas niveau des algorithmes de le faire sur le but—mais il doit généralement être évitée. @Steve Gury donner un bon exemple de cas où il pourrait être un problème.

Conditions de course se produire dans les applications multi-thread ou processus multiples systèmes. Une condition de concurrence, à la base, c'est tout ce qui fait l'hypothèse que deux choses à ne pas dans le même thread ou processus qui va se passer dans un ordre particulier, sans prendre des mesures pour s'assurer qu'ils font. Cela se produit généralement lorsque deux threads sont la transmission de messages par l'établissement et la vérification des variables membres d'une classe à la fois peut accéder. Il y a presque toujours une condition de concurrence lorsqu'un thread appelle le sommeil, pour donner un autre thread de temps pour terminer une tâche (à moins que le sommeil est dans une boucle, avec un certain mécanisme de vérification).

Outils de prévention des conditions de course sont tributaires de la langue et de l'OS, mais certains comon sont les mutex, les sections critiques, et des signaux. Les mutex sont bons quand vous voulez vous assurer que vous êtes le seul à faire quelque chose. Les signaux sont bons quand vous voulez vous assurer que quelqu'un d'autre a fini de faire quelque chose. En minimisant les ressources partagées peuvent également aider à prévenir des comportements inattendus

La détection des conditions de course peut être difficile, mais il ya un couple de signes. Code qui s'appuie fortement sur dort est sujette à des conditions de course, afin de vérifier d'abord pour les appels à dormir dans le code affecté. L'ajout d'particulièrement longue dort peut également être utilisé à des fins de débogage pour essayer de le forcer un ordre particulier pour les événements. Cela peut être utile pour reproduire le comportement, voir si vous pouvez le faire disparaître par la modification de la chronologie des choses, et pour tester les solutions mises en place. L'dort doit être retiré après le débogage.

La signature signe que l'on a une condition cependant, c'est si il y a un problème qui ne se produit que de façon intermittente sur certaines machines. Commune de bugs serait plantages et blocages. Avec la journalisation, vous devriez être capable de trouver la zone touchée et de travailler à partir de là.

Une condition de concurrence est une situation sur la programmation simultanée lorsque deux threads simultanés ou les processus de compétition pour une ressource, et le résultat final de l'état dépend de la personne qui obtient la ressource première.

Ce qui est une condition de concurrence?

La situation lorsque le processus est critique dépend de la séquence ou du calendrier des autres manifestations.

Par exemple,
Processeur Un processeur et B à la fois des besoins identiques ressource pour leur exécution.

Comment les détecter?

Il y a des outils de détection de condition de course automatiquement:

• Verrou De Courses À Base De Vérificateur
• -Passe-Avant La Course De Détection
• Hybride De Course De Détection

Comment fais-tu?

Condition de course peuvent être traitées par Mutex ou Sémaphores. Ils agissent comme un verrou permet à un processus d'acquisition de ressources fondées sur certaines exigences relatives à la prévention condition de course.

Comment les empêcher de se produire?

Il existe différentes façons de prévenir la condition de course, comme Section Critique de l'Évitement de la.

1. Deux processus simultanément à l'intérieur de leurs régions critiques. (Exclusion Mutuelle)
2. Aucune des hypothèses sont formulées sur la vitesse ou le nombre de Processeurs.
3. Pas de processus en cours d'exécution à l'extérieur de sa région critique qui bloque les autres processus.
4. Aucun processus n'a plus qu'à attendre une éternité pour entrer dans sa région critique. (A attend pour B de ressources, B attend C ressources, C attend Un ressources)

Ici, c'est le classique Compte en Banque qui va aider les débutants à comprendre les Threads en Java facilement w.r.t. conditions de course:

public class BankAccount {

/**
 * @param args
 */
int accountNumber;
double accountBalance;

public synchronized boolean Deposit(double amount){
    double newAccountBalance=0;
    if(amount<=0){
        return false;
    }
    else {
        newAccountBalance = accountBalance+amount;
        accountBalance=newAccountBalance;
        return true;
    }

}
public synchronized boolean Withdraw(double amount){
    double newAccountBalance=0;
    if(amount>accountBalance){
        return false;
    }
    else{
        newAccountBalance = accountBalance-amount;
        accountBalance=newAccountBalance;
        return true;
    }
}

public static void main(String[] args) {
    //TODO Auto-generated method stub
    BankAccount b = new BankAccount();
    b.accountBalance=2000;
    System.out.println(b.Withdraw(3000));

}

Essayez cet exemple de base pour une meilleure compréhension de la condition de course:

    public class ThreadRaceCondition {

    /**
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        Account myAccount = new Account(22222222);

        //Expected deposit: 250
        for (int i = 0; i < 50; i++) {
            Transaction t = new Transaction(myAccount,
                    Transaction.TransactionType.DEPOSIT, 5.00);
            t.start();
        }

        //Expected withdrawal: 50
        for (int i = 0; i < 50; i++) {
            Transaction t = new Transaction(myAccount,
                    Transaction.TransactionType.WITHDRAW, 1.00);
            t.start();

        }

        //Temporary sleep to ensure all threads are completed. Don't use in
        //realworld :-)
        Thread.sleep(1000);
        //Expected account balance is 200
        System.out.println("Final Account Balance: "
                + myAccount.getAccountBalance());

    }

}

class Transaction extends Thread {

    public static enum TransactionType {
        DEPOSIT(1), WITHDRAW(2);

        private int value;

        private TransactionType(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }
    };

    private TransactionType transactionType;
    private Account account;
    private double amount;

    /*
     * If transactionType == 1, deposit else if transactionType == 2 withdraw
     */
    public Transaction(Account account, TransactionType transactionType,
            double amount) {
        this.transactionType = transactionType;
        this.account = account;
        this.amount = amount;
    }

    public void run() {
        switch (this.transactionType) {
        case DEPOSIT:
            deposit();
            printBalance();
            break;
        case WITHDRAW:
            withdraw();
            printBalance();
            break;
        default:
            System.out.println("NOT A VALID TRANSACTION");
        }
        ;
    }

    public void deposit() {
        this.account.deposit(this.amount);
    }

    public void withdraw() {
        this.account.withdraw(amount);
    }

    public void printBalance() {
        System.out.println(Thread.currentThread().getName()
                + " : TransactionType: " + this.transactionType + ", Amount: "
                + this.amount);
        System.out.println("Account Balance: "
                + this.account.getAccountBalance());
    }
}

class Account {
    private int accountNumber;
    private double accountBalance;

    public int getAccountNumber() {
        return accountNumber;
    }

    public double getAccountBalance() {
        return accountBalance;
    }

    public Account(int accountNumber) {
        this.accountNumber = accountNumber;
    }

    //If this method is not synchronized, you will see race condition on
    //Remove syncronized keyword to see race condition
    public synchronized boolean deposit(double amount) {
        if (amount < 0) {
            return false;
        } else {
            accountBalance = accountBalance + amount;
            return true;
        }
    }

    //If this method is not synchronized, you will see race condition on
    //Remove syncronized keyword to see race condition
    public synchronized boolean withdraw(double amount) {
        if (amount > accountBalance) {
            return false;
        } else {
            accountBalance = accountBalance - amount;
            return true;
        }
    }
}

Envisager une opération qui a pour afficher le nombre dès que le compte est incrémenté. c'est à dire., dès que CounterThread incrémente la valeur DisplayThread besoins pour afficher la récente mise à jour de la valeur.

int i = 0;

Sortie

CounterThread -> i = 1  
DisplayThread -> i = 1  
CounterThread -> i = 2  
CounterThread -> i = 3  
CounterThread -> i = 4  
DisplayThread -> i = 4

Ici CounterThread obtient le verrou et fréquemment mises à jour de la valeur avant de DisplayThread l'affiche. Ici, il existe une condition de Course. Condition de course peuvent être résolus en utilisant Synchronzation

public class Synchronized_RACECONDITION {
    private static final int NUM_INCREMENTS = 10000;

    private static int count = 0;

    public static void main(String[] args) {
        testSyncIncrement();
        testNonSyncIncrement();
    }

    private static void testSyncIncrement() {
        count = 0;

        ExecutorService executor = Executors.newFixedThreadPool(2);

        IntStream.range(0, NUM_INCREMENTS)
                .forEach(i -> executor.submit(Synchronized_RACECONDITION::incrementSync));

        ConcurrentUtils.stop(executor);

        System.out.println("   Sync: " + count);
    }

    private static void testNonSyncIncrement() {
        count = 0;

        ExecutorService executor = Executors.newFixedThreadPool(2);

        IntStream.range(0, NUM_INCREMENTS)
                .forEach(i -> executor.submit(Synchronized_RACECONDITION::increment));

        ConcurrentUtils.stop(executor);

        System.out.println("NonSync: " + count);
    }

    private static synchronized void incrementSync() {
        count = count + 1;
    }

    private static void increment() {
        count = count + 1;
    }
static  class ConcurrentUtils {

    public static void stop(ExecutorService executor) {
        try {
            executor.shutdown();
            executor.awaitTermination(60, TimeUnit.SECONDS);
        }
        catch (InterruptedException e) {
            System.err.println("termination interrupted");
        }
        finally {
            if (!executor.isTerminated()) {
                System.err.println("killing non-finished tasks");
            }
            executor.shutdownNow();
        }
    }
}
}