Was ist eine race condition?

Einer "race condition" besteht, wenn Multithreading (oder eine andere parallel -) code, der auf eine freigegebene Ressource zugreifen könnten, tun dies in einer Weise zu unerwarteten Ergebnissen führen.

Nehmen Sie dieses Beispiel:

for ( int i = 0; i < 10000000; i++ )
{
   x = x + 1; 
}

Wenn Sie hatte 5 threads ausführen dieses Codes auf einmal, der Wert von x WÜRDE NICHT am Ende wird 50,000,000. Es wäre in der Tat unterscheiden sich mit jedem Lauf.

Dies ist da, um für jeden thread, erhöht sich der Wert von x, haben Sie Folgendes zu tun: (vereinfacht natürlich),

Um den Wert von x 
Fügen Sie 1, um diesen Wert 
Speichern Sie diesen Wert auf x 

Jedem thread in jedem Schritt in diesem Prozess zu jeder Zeit, und Sie können Schritt für Schritt auf einander, wenn einer freigegebenen Ressource beteiligt ist. Der Zustand von x verändert werden kann, durch einen anderen thread in der Zeit zwischen x gelesen wird und wenn es geschrieben ist, zurück.

Angenommen ein thread ruft den Wert von x, aber noch nicht gespeichert ist es noch nicht. Ein anderer thread kann auch wieder die gleiche Wert von x (weil kein Gewinde geändert hat es noch) und dann würden Sie beide speichern die gleiche - Wert (x+1) x!

Beispiel:

Thread 1: liest x, - Wert ist 7 
Thread 1: fügen Sie 1 bis x, der Wert ist jetzt 8 
Thread 2: liest x, ist der Wert 7 
Thread 1: speichert 8 in x 
Thread 2: addiert 1 zu x, Wert ist jetzt 8 
Thread 2: speichert 8 in x 

Race conditions vermieden werden können durch den Einsatz von irgendeiner Art von Verschluss - Mechanismus, bevor der code für den Zugriff auf die freigegebene Ressource:

for ( int i = 0; i < 10000000; i++ )
{
   //lock x
   x = x + 1; 
   //unlock x
}

Hier, die Antwort kommt wie von 50.000.000 jeder Zeit.

Mehr zu sperren, Suche nach: mutex, semaphore, critical section, gemeinsam genutzte Ressource.

InformationsquelleAutor der Antwort privatehuff

Gibt es einen wichtigen technischen Unterschied zwischen race-conditions und data races. Die meisten Antworten scheinen, um die Annahme, dass diese Begriffe gleichbedeutend sind, aber Sie sind es nicht.

Einem data race tritt auf, wenn 2 Hinweise auf den gleichen Speicherplatz von mindestens einer dieser Zugänge ist ein schreiben und es ist keine passiert, bevor Sie bestellen unter diesen zugreift. Nun was ist passiert, bevor die Bestellung ist Gegenstand vieler Debatten, aber im Allgemeinen ulock-lock-Paare auf dem gleichen lock-variable und warten-signal-Paare auf die gleiche bedingungsvariable induzieren passiert-vor der Bestellung.

Einer race condition ist ein semantischer Fehler. Es ist ein Fehler, der Auftritt, in den der Zeitpunkt oder die Reihenfolge der Ereignisse, führt zu falschen Programm Verhalten.

Viele race conditions werden können (und tatsächlich sind), verursacht durch die Daten Rennen, aber das ist nicht notwendig. Als eine Angelegenheit von der Tat, die Daten, die Rennen und Rennen Bedingungen sind weder die notwendige, noch die hinreichende Bedingung für einen anderen. Diese blog-post erklärt auch den Unterschied sehr gut, mit einer einfachen bank-Transaktion Beispiel. Hier ist ein weiteres einfaches Beispielerklärt den Unterschied.

Nun, dass wir nagelfest ist die Terminologie, lassen Sie uns versuchen, eine Antwort auf die ursprüngliche Frage.

Gegeben, dass race-conditions sind semantische Fehler, es gibt keinen Allgemeinen Weg, Sie zu erkennen. Dies ist, weil es keine Möglichkeit gibt, dass ein automatisiertes Orakel, das unterscheiden kann, richtige vs. falsche Verhalten des Programms in den Allgemeinen Fall. Rennen ist die Erkennung eines unentscheidbaren Problems.

Auf der anderen Seite Daten, die Rennen haben eine genaue definition, bezieht sich nicht unbedingt auf Richtigkeit, und daher kann man Sie entdeckt. Es gibt viele Varianten von Daten-race-Detektoren (statische/dynamische data-race-Erkennung, lockset-basierte data-race-Erkennung, passiert-bevor-basierten data race detection, hybrid-data-race-Erkennung). Ein state of the art dynamic data race detector ist ThreadSanitizer das funktioniert in der Praxis sehr gut.

Umgang mit Daten, die Rennen im Allgemeinen erfordert einige Programmier-Disziplin zu induzieren passiert-bevor die Kanten zwischen den Zugriffen auf gemeinsame Daten (während der Entwicklung, oder, sobald Sie erkannt werden mit den oben genannten tools). dies kann durch locks, condition Variablen, Semaphoren, etc.. Allerdings kann man sich auch beschäftigen verschiedene Programmier-Paradigmen, wie message passing (statt shared memory), die Daten vermeiden Rennen mit dem Bau.

InformationsquelleAutor der Antwort Baris Kasikci

Einer race condition ist eine Art bug, das passiert nur mit bestimmten zeitlichen Bedingungen.

Beispiel:
Stellen Sie sich vor Sie haben zwei threads A und B.

In Thread A:

if( object.a != 0 )
    object.avg = total / object.a

In Thread B:

object.a = 0

Wenn Ein thread präemptiv unterbrochen wird, nachdem Sie gerade prüfen, das Objekt.einen nicht null ist, wird B tun a = 0und wenn der thread Eine wird gewinnen, der Prozessor, es wird eine "Division durch null".

Dieser Fehler nur passieren, wenn Ein thread präemptiv unterbrochen wird nur nach der if-Anweisung, es ist sehr selten, aber es kann passieren.

InformationsquelleAutor der Antwort Steve Gury

Race-condition ist nicht nur im Zusammenhang mit der software, aber auch im Zusammenhang mit der hardware zu. Eigentlich ist die Bezeichnung war zunächst geprägt von der hardware-Industrie.

Laut wikipedia:

Der Begriff stammt die Idee zwei Signale racing einander zu
Einfluss auf den Ausgang der ersten.

Race-Bedingung in einer Logik-Schaltung:

Software-Industrie nahm diesen Begriff ohne änderung, das macht es ein wenig schwierig zu verstehen.

Müssen Sie einige Ersatz-zuordnen der software-Welt:

• "zwei-Signale" => "zwei " threads"/"zwei Prozesse"
• "Einfluss auf den Ausgang" => "Einfluss auf einen freigegebenen Zustand"

Also "race condition" in software-Branche bedeutet "zwei " threads"/"zwei Prozesse" - Rennen sich gegenseitig um "Einfluss auf einen freigegebenen Zustand", und das endgültige Ergebnis der freigegebene Status wird davon abhängen, einige subtile zeitliche Differenz, die hervorgerufenen werden konnte durch einige bestimmten thread/Prozess starten, um die thread - /Prozess-scheduling, etc.

InformationsquelleAutor der Antwort nybon

Einer race condition ist eine situation, auf concurrent programming, wo zwei gleichzeitige threads oder Prozessen und der daraus resultierende Endzustand hängt davon ab, wer bekommt die Ressource zuerst.

InformationsquelleAutor der Antwort Jorge Córdoba

Hier ist das klassische Bankkonto Beispiel, die helfen Neulinge verstehen, Threads in Java leicht w.r.t. race conditions:

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));

}

InformationsquelleAutor der Antwort realPK

Versuchen, dieses grundlegende Beispiel für ein besseres Verständnis von race-Bedingung:

    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;
        }
    }
}

InformationsquelleAutor der Antwort Morsu

Überlegen, eine operation, die anzeigen zu zählen, sobald die Anzahl wird inkrementiert. dh., sobald CounterThread inkrementiert den Wert DisplayThread muss, um die Anzeige der zuletzt aktualisierte Wert.

int i = 0;

Ausgabe

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

Hier CounterThread wird das Schloss Häufig und aktualisiert den Wert vor DisplayThread zeigt es. Hier existiert eine Race-condition. Race-Bedingung kann gelöst werden durch die Verwendung Synchronzation

InformationsquelleAutor der Antwort bharanitharan