Atomic Instruction

Atomic kommt aus dem griechischen ἄτομος (atomos) was bedeutet "unteilbar". (Vorsicht: ich spreche kein Griechisch, also vielleicht ist es wirklich etwas anderes, aber die meisten Englisch-Sprecher unter Berufung auf Etymologien interpretieren es auf diese Weise. 🙂

In computing, dies bedeutet, dass der Betrieb, nun, kommt vor. Es gibt keinen Zwischenzustand, die sichtbar ist, bevor es abgeschlossen ist. Also, wenn deine CPU unterbrochen wird, um service-hardware (IRQ), oder wenn eine andere CPU liest den gleichen Speicher, es hat keinen Einfluss auf das Ergebnis, und diese anderen Vorgänge beobachten, entweder als abgeschlossen oder noch nicht gestartet.

Als Beispiel... sagen wir, Sie wollten, um eine variable zu setzen, um etwas, aber nur, wenn es nicht gesetzt wurde, bevor. Man könnte geneigt sein, dies zu tun:

if (foo == 0)
{
   foo = some_function();
}

Aber was ist, wenn diese parallel laufen? Es könnte sein, dass das Programm holt foo, sehen es als null, derweil thread 2 kommt zusammen und tut das gleiche und setzt den Wert auf etwas. Zurück in den ursprünglichen thread, der code immer noch denkt, dass foo null ist, und die variable erhält zweimal vergeben.

Für Fälle wie diese, die CPU enthält einige Anweisungen, die das können der Vergleich und der bedingte Zuordnung als eine Atomare Einheit. Daher, test-and-set, compare-and-swap-und load-linked/store-conditional. Sie können diese implementieren, sperren (Ihr Betriebssystem und Ihre C-Bibliothek gemacht hat.) Oder Sie können schreiben, ein-aus-algorithmen, die sich auf die primitive, etwas zu tun. (Es gibt Coole Sachen die hier gemacht werden, aber die meisten Normalsterblichen vermeiden, aus Angst, falsch verstanden haben.)

Unten sind einige meiner Hinweise auf die Atomarität, die helfen können Sie verstehen die Bedeutung. Die Notizen sind die Quellen aufgelistet, am Ende, und ich empfehle die Lektüre einige von Ihnen, wenn Sie brauchen eine Gründliche Erklärung eher als Punkt-form-Kugeln, die ich habe. Bitte jegliche Fehler, so dass ich Sie korrigieren.

Definition :

• Aus dem griechischen und bedeutet "nicht teilbar in kleinere Teile"
• Eine "Atomare" operation ist immer beobachtet zu werden getan oder nicht getan, aber
  nie auf halbem Weg getan.
• Eine Atomare operation muss durchgeführt werden, ganz oder nicht durchgeführt werden bei
  alle.
• In multi-threaded-Szenarien, die eine variable geht aus unmutated zu
  mutierte direkt, ohne "auf halbem Weg mutiert" Werte

Beispiel 1 : Atomare Operationen

• Betrachten Sie die folgenden ganzen zahlen verwendet, die von verschiedenen threads :

   int X = 2;
   int Y = 1;
   int Z = 0;
  
   Z = X;  //Thread 1
  
   X = Y;  //Thread 2
  

• Im obigen Beispiel werden zwei threads nutzen von X -, Y-und Z -

• Jeder Lesen und schreiben sind Atomare
• Die threads Rennen :
  • Wenn thread 1 gewinnt, dann Z = 2
  • Wenn thread 2 gewinnt, dann Z=1
  • Z wird definitiv einer dieser beiden Werte

Beispiel 2 : Nicht-Atomare Operationen : ++/-- Operationen

• Betrachten Sie die Inkrement - /Dekrement-Ausdrücke :

  i++;  //increment
  i--;  //decrement
  

• Operationen übersetzen :

  1. Lese ich
  2. Inkrementieren/Dekrementieren den Wert Lesen
  3. Schreiben Sie den neuen Wert zurück ich
• Die Operationen bestehen aus jeweils 3 Atomare Operationen, und sind nicht atomar sich
• Zwei versuche Inkrementieren ich in separaten threads könnte interleave, so dass einer von den Schritten verloren

Beispiel 3 - Nicht-Atomare Operationen : Werte, die größer als 4-Byte -

• Betrachten Sie die folgenden unveränderlichen Struktur :

  struct MyLong
   {
       public readonly int low;
       public readonly int high;

       public MyLong(int low, int high)
       {
           this.low = low;
           this.high = high;
       }
   }

• Schaffen wir Felder mit bestimmten Werten des Typs MyLong :

  MyLong X = new MyLong(0xAAAA, 0xAAAA);   
  MyLong Y = new MyLong(0xBBBB, 0xBBBB);     
  MyLong Z = new MyLong(0xCCCC, 0xCCCC);
  

• Ändern wir unsere Felder in separate threads ohne thread-Sicherheit :

  X = Y; //Thread 1                                  
  Y = X; //Thread 2
  

• In .NET, beim kopieren einen Wert geben, wird die CLR nicht an einen Konstruktor - es verschiebt die bytes einer atomaren operation zu einem Zeitpunkt,

• Weil dieses, die Aktivitäten in den beiden threads sind jetzt vier Atomare Operationen
• Wenn es keine thread-Sicherheit durchgesetzt wird, können die Daten beschädigt werden,

• Betrachten Sie die folgende Reihenfolge der Ausführung von Operationen :

  X.low = Y.low;      //Thread 1 - X = 0xAAAABBBB            
  Y.low = Z.low;      //Thread 2 - Y = 0xCCCCBBBB              
  Y.high = Z.high;    //Thread 2 - Y = 0xCCCCCCCC             
  X.high = Y.high;    //Thread 1 - X = 0xCCCCBBBB   <-- corrupt value for X
  

• Lesen und schreiben Werte, die größer sind als 32-bit auf mehrere threads auf einem 32-bit-Betriebssystem ohne Zusatz von irgendeine Art von Verriegelung, um die operation atomar ist, die wahrscheinlich zu korrupten Daten wie oben

Prozessor Operationen

• Auf allen modernen Prozessoren, können Sie davon ausgehen, dass lese-und Schreibvorgänge der natürlich ausgerichtet nativen Typen sind atomar, solange :

  • 1 : Die Speicher-bus ist mindestens so breit wie der Typ der gerade gelesen oder geschrieben
  • 2 : Die CPU liest und schreibt diesen Typen in einer einzigen bus-Transaktion, so dass es unmöglich für die anderen threads zu sehen, wie Sie in einer halben erledigt

• Auf x86-und X64-es gibt keine Garantie, dass liest und schreibt, die größer als acht Byte sind Atomare

• Prozessor-Hersteller definieren die atomaren Operationen, die für jeden Prozessor in einem Software Developer ' s Manual
• In einzelnen Prozessoren /single-core-Systemen ist es möglich, die Verwendung von standard-locking-Techniken, um zu verhindern, dass die CPU-Anweisungen unterbrochen wird, dies kann aber ineffizient sein
• Deaktivieren der interrupts ist eine weitere effiziente Lösung, wenn möglich
• In Multiprozessor - /multicore-Systemen ist es möglich, noch sperren, sondern lediglich mit einer einzigen Anweisung oder deaktivieren von interrupts garantiert nicht Atomare Zugriff
• Atomarität kann erreicht werden, indem sichergestellt wird, dass die Anweisungen, die zur Geltendmachung der 'LOCK' - signal auf dem bus zu verhindern, dass andere Prozessoren im system aus Zugriff auf den Speicher gleichzeitig

Sprache Unterschiede

C#

• C# gewährleistet, dass Aktionen auf einer integrierten Wert-Typ, der dauert bis zu 4-bytes sind Atomare
• Operationen auf Datentypen, die mehr als vier bytes (double, long, etc.) nicht garantiert werden atomaren
• Die CLI garantiert, dass lese-und Schreibvorgänge der Variablen Wert geben, die die Größe (oder kleiner) des Prozessors, die Natürliche Größe des Zeigers sind atomic
  • Ex - ausführen von C# auf einem 64-bit-Betriebssystem in einer 64-bit-version der CLR führt lese-und Schreibvorgänge von 64-bit-Double-und long Integer atomar
• Erstellen Atomare Operationen :
  • .NET provodes die Interlocked-Klasse als Teil des Systems.Threading-namespace
  • Die Interlocked-Klasse bietet Atomare Operationen wie Inkrementieren, vergleichen, tauschen, etc.

using System.Threading;             

int unsafeCount;                          
int safeCount;                           

unsafeCount++;                              
Interlocked.Increment(ref safeCount);

C++

• C++ - standard garantiert nicht Atomare Verhalten
• Alle C /C++ Operationen vermutet, non-atomic, sofern nicht anders angegeben, die vom compiler oder hardware-Hersteller - darunter 32-bit-integer-Zuweisung
• Erstellen Atomare Operationen :
  • Die C++ 11 concurrency-Bibliothek enthält die - Atomare Operationen-Bibliothek ()
  • Die Atomic-Bibliothek stellt Atomare Datentypen als template-Klasse zu verwenden Sie mit jeder Art Sie wollen
  • Operationen auf Atomare Datentypen sind atomar und somit thread-sicher

struct AtomicCounter

{

   std::atomic< int> value;   

   void increment(){                                    
       ++value;                                
   }           

   void decrement(){                                         
       --value;                                                 
   }

   int get(){                                             
       return value.load();                                    
   }      

}

Java

• Java garantiert, dass Operationen, die auf alle integrierten Wert-Typ, der dauert bis zu 4-bytes sind Atomare
• Zuordnungen zu den flüchtigen longs und doubles sind auch garantiert atomic
• Java bietet ein kleines toolkit-Klassen, support-lock-freien thread-sichere Programmierung auf einzelne Variablen, die durch die java.util.gleichzeitige.atomic
• Dies bietet atomic-lock-freien Operationen basierend auf low-level-atomic-hardware-primitive, wie compare-and-swap (CAS), auch als vergleichen und einstellen :
  • CAS form - boolean compareAndSet(expectedValue, updateValue );
    • Diese Methode atomar legt eine variable, um die updateValue, wenn es hält derzeit die expectedValue - reporting true bei Erfolg,

import java.util.concurrent.atomic.AtomicInteger;

public class Counter
{
     private AtomicInteger value= new AtomicInteger();

     public int increment(){
         return value.incrementAndGet();  
     }

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

Quellen

http://www.evernote.com/shard/s10/sh/c2735e95-85ae-4d8c-a615-52aadc305335/99de177ac05dc8635fb42e4e6121f1d2