JavaScript SharedArrayBuffer låsfria datastrukturer: Atomära operationer

Inom modern webbutveckling och server-side JavaScript-miljöer som Node.js växer behovet av effektiv samtidig programmering ständigt. När applikationer blir mer komplexa och kräver högre prestanda, utforskar utvecklare alltmer tekniker för att utnyttja flera kärnor och trådar. Ett kraftfullt verktyg för att uppnå detta i JavaScript är SharedArrayBuffer, kombinerat med Atomics-operationer, vilket möjliggör skapandet av låsfria datastrukturer.

Introduktion till samtidighet i JavaScript

Traditionellt har JavaScript varit känt som ett entrådat språk. Detta innebär att endast en uppgift kan utföras åt gången inom en given exekveringskontext. Även om detta förenklar många aspekter av utvecklingen, kan det också vara en flaskhals för beräkningsintensiva uppgifter. Web Workers erbjuder ett sätt att köra JavaScript-kod i bakgrundstrådar, men kommunikationen mellan workers har traditionellt varit asynkron och inneburit kopiering av data.

SharedArrayBuffer ändrar detta genom att tillhandahålla ett minnesområde som kan nås av flera trådar samtidigt. Denna delade åtkomst introducerar dock risken för kapplöpningstillstånd (race conditions) och datakorruption. Det är här Atomics kommer in i bilden. Atomics tillhandahåller en uppsättning atomära operationer som garanterar att operationer på delat minne utförs odelbart, vilket förhindrar datakorruption.

Förståelse för SharedArrayBuffer

SharedArrayBuffer är ett JavaScript-objekt som representerar en rå binär databuffert med fast längd. Till skillnad från en vanlig ArrayBuffer kan en SharedArrayBuffer delas mellan flera trådar (Web Workers) utan att kräva explicit kopiering av data. Detta möjliggör verklig samtidighet med delat minne.

Exempel: Skapa en SharedArrayBuffer

            
const sab = new SharedArrayBuffer(1024); // 1KB SharedArrayBuffer

            

              
                Copy
              
            
          

För att komma åt datan inuti SharedArrayBuffer måste du skapa en typad array-vy, såsom Int32Array eller Float64Array:

            
const int32View = new Int32Array(sab);

            

              
                Copy
              
            
          

Detta skapar en Int32Array-vy över SharedArrayBuffer, vilket gör att du kan läsa och skriva 32-bitars heltal till det delade minnet.

Rollen för Atomics

Atomics är ett globalt objekt som tillhandahåller atomära operationer. Dessa operationer garanterar att läsningar och skrivningar till delat minne utförs atomärt, vilket förhindrar kapplöpningstillstånd. De är avgörande för att bygga låsfria datastrukturer som kan nås säkert av flera trådar.

Viktiga atomära operationer:

• Atomics.load(typedArray, index): Läser ett värde från det angivna indexet i den typade arrayen.
• Atomics.store(typedArray, index, value): Skriver ett värde till det angivna indexet i den typade arrayen.
• Atomics.add(typedArray, index, value): Adderar ett värde till värdet på det angivna indexet.
• Atomics.sub(typedArray, index, value): Subtraherar ett värde från värdet på det angivna indexet.
• Atomics.exchange(typedArray, index, value): Ersätter värdet på det angivna indexet med ett nytt värde och returnerar det ursprungliga värdet.
• Atomics.compareExchange(typedArray, index, expectedValue, newValue): Jämför värdet på det angivna indexet med ett förväntat värde. Om de är lika, ersätts värdet med ett nytt värde. Returnerar det ursprungliga värdet.
• Atomics.wait(typedArray, index, expectedValue, timeout): Väntar på att ett värde på det angivna indexet ska ändras från ett förväntat värde.
• Atomics.wake(typedArray, index, count): Väcker ett specificerat antal väntande trådar som väntar på ett värde vid det angivna indexet.

Dessa operationer är grundläggande för att bygga låsfria algoritmer.

Bygga låsfria datastrukturer

Låsfria datastrukturer är datastrukturer som kan nås av flera trådar samtidigt utan att använda lås. Detta eliminerar den overhead och de potentiella låsningar (deadlocks) som är förknippade med traditionella låsmekanismer. Med hjälp av SharedArrayBuffer och Atomics kan vi implementera olika låsfria datastrukturer i JavaScript.

1. Låsfri räknare

Ett enkelt exempel är en låsfri räknare. Denna räknare kan ökas och minskas av flera trådar utan några lås.

            
class LockFreeCounter {
  constructor() {
    this.buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
    this.view = new Int32Array(this.buffer);
  }

  increment() {
    Atomics.add(this.view, 0, 1);
  }

  decrement() {
    Atomics.sub(this.view, 0, 1);
  }

  getValue() {
    return Atomics.load(this.view, 0);
  }
}

// Exempelanvändning i två web workers
const counter = new LockFreeCounter();

// Worker 1
for (let i = 0; i < 1000; i++) {
  counter.increment();
}

// Worker 2
for (let i = 0; i < 1000; i++) {
  counter.decrement();
}

// Efter att båda workers har slutförts (med en mekanism som Promise.all för att säkerställa slutförande)
// counter.getValue() bör vara nära 0. Det faktiska resultatet kan variera på grund av samtidighet

            

              
                Copy
              
            
          

2. Låsfri stack

Ett mer komplext exempel är en låsfri stack. Denna stack använder en länkad liststruktur som lagras i SharedArrayBuffer och atomära operationer för att hantera huvudpekaren.

            
class LockFreeStack {
  constructor(capacity) {
    this.capacity = capacity;
    // Varje nod kräver utrymme för ett värde och en pekare till nästa nod
    // Allokera utrymme för noder och en huvudpekare
    this.buffer = new SharedArrayBuffer((capacity + 1) * 2 * Int32Array.BYTES_PER_ELEMENT); // Värde & Nästa-pekare för varje nod + Huvudpekare
    this.view = new Int32Array(this.buffer);

    this.headIndex = capacity * 2; // index där huvudpekaren lagras
    Atomics.store(this.view, this.headIndex, -1); // Initiera huvudet till null (-1)

    // Initiera noderna med sina 'next'-pekare för senare återanvändning.
    for (let i = 0; i < capacity; i++) {
      const nextIndex = (i === capacity - 1) ? -1 : i + 1; // sista noden pekar på null
      this.setNext(i, nextIndex);
    }

    this.freeListHead = 0; // Initiera huvudet för den fria listan till den första noden
  }

  setNext(nodeIndex, nextIndex) {
     this.view[nodeIndex * 2 + 1] = nextIndex;
  }

  getNext(nodeIndex) {
     return this.view[nodeIndex * 2 + 1];
  }

  getValue(nodeIndex) {
    return this.view[nodeIndex * 2];
  }

  setValue(nodeIndex, value){ 
      this.view[nodeIndex*2] = value;
  }

  push(value) {
    let nodeIndex = this.freeListHead; // försök att hämta från freeList
    if (nodeIndex === -1) {
      return false; // stack overflow
    }

    let nextFree = this.getNext(nodeIndex);
    // försök atomärt att uppdatera freeList-huvudet till nextFree. Om vi misslyckas har någon annan redan tagit det.
    if (Atomics.compareExchange(this.view, this.capacity*2, nodeIndex, nextFree) !== nodeIndex) {
        return false; // försök igen vid konkurrens
    }

    // vi har en nod, skriv värdet i den
    this.setValue(nodeIndex, value);

    let head;
    let newHead = nodeIndex;

    do {
      head = Atomics.load(this.view, this.headIndex);
      this.setNext(newHead, head);
      // Jämför-och-byt ut huvudet med newHead. Om det misslyckas betyder det att en annan tråd har pushat emellan
    } while (Atomics.compareExchange(this.view, this.headIndex, head, newHead) !== head);

    return true; // lyckades
  }

  pop() {
    let head = Atomics.load(this.view, this.headIndex);
    if (head === -1) {
      return undefined; // stacken är tom
    }

    let next = this.getNext(head);
    // Försök att uppdatera huvudet till nästa. Om det misslyckas betyder det att en annan tråd har poppat emellan
    if (Atomics.compareExchange(this.view, this.headIndex, head, next) !== head) {
      return undefined; // försök igen, eller indikera misslyckande.
    }

    const value = this.getValue(head);

    // Återlämna noden till den fria listan.
    let currentFreeListHead = this.freeListHead;
    do {
        this.setNext(head, currentFreeListHead); // peka den frigjorda noden till den nuvarande fria listan
    } while(Atomics.compareExchange(this.view, this.capacity*2, currentFreeListHead, head) !== currentFreeListHead);

    return value; // lyckades
  }
}

// Exempelanvändning (i en worker):
const stack = new LockFreeStack(1024); // Skapa en stack med 1024 element

//pusha
stack.push(10);
stack.push(20);

//poppa
const value1 = stack.pop(); // Värde 20
const value2 = stack.pop(); // Värde 10


            

              
                Copy
              
            
          

3. Låsfri kö

Att bygga en låsfri kö innebär att hantera både huvud- och svanspekare atomärt. Detta är mer komplext än stacken men följer liknande principer med hjälp av Atomics.compareExchange.

Notera: En detaljerad implementering av en låsfri kö skulle vara mer omfattande och ligger utanför ramen för denna introduktion, men skulle involvera liknande koncept som stacken, noggrann minneshantering och användning av CAS-operationer (Compare-and-Swap) för att garantera säker samtidig åtkomst.

Fördelar med låsfria datastrukturer

• Förbättrad prestanda: Att eliminera lås minskar overhead och undviker konkurrens, vilket leder till högre genomströmning.
• Undvikande av låsningar (Deadlocks): Låsfria algoritmer är i sig själva fria från låsningar eftersom de inte förlitar sig på lås.
• Ökad samtidighet: Tillåter fler trådar att komma åt datastrukturen samtidigt utan att blockera varandra.

Utmaningar och överväganden

• Komplexitet: Att implementera låsfria algoritmer kan vara komplext och felbenäget. Det kräver en djup förståelse för samtidighet och minnesmodeller.
• ABA-problemet: ABA-problemet uppstår när ett värde ändras från A till B och sedan tillbaka till A. En jämför-och-byt-operation kan felaktigt lyckas, vilket leder till datakorruption. Lösningar på ABA-problemet innebär ofta att man lägger till en räknare till det värde som jämförs.
• Minneshantering: Noggrann minneshantering krävs för att undvika minnesläckor och säkerställa korrekt allokering och deallokering av resurser. Tekniker som hazard pointers eller epokbaserad återvinning kan användas.
• Felsökning: Att felsöka samtidig kod kan vara utmanande, eftersom problem kan vara svåra att reproducera. Verktyg som debuggers och profilers kan vara till hjälp.

Praktiska exempel och användningsfall

Låsfria datastrukturer kan användas i olika scenarier där hög samtidighet och låg latens krävs:

• Spelutveckling: Hantera speltillstånd och synkronisera data mellan flera speltrådar.
• Realtidssystem: Bearbeta dataströmmar och händelser i realtid.
• Högpresterande servrar: Hantera samtidiga förfrågningar och förvalta delade resurser.
• Databehandling: Parallell bearbetning av stora datamängder.
• Finansiella applikationer: Utföra högfrekvenshandel och riskhanteringsberäkningar.

Exempel: Realtidsdatabehandling i en finansiell applikation

Föreställ dig en finansiell applikation som bearbetar aktiemarknadsdata i realtid. Flera trådar behöver komma åt och uppdatera delade datastrukturer som representerar aktiekurser, orderböcker och handelspositioner. Genom att använda låsfria datastrukturer kan applikationen effektivt hantera den höga volymen av inkommande data och säkerställa snabb exekvering av affärer.

Webbläsarkompatibilitet och säkerhet

SharedArrayBuffer och Atomics stöds brett i moderna webbläsare. På grund av säkerhetsproblem relaterade till Spectre- och Meltdown-sårbarheterna inaktiverade webbläsare dock initialt SharedArrayBuffer som standard. För att återaktivera det behöver du vanligtvis ställa in följande HTTP-svarshuvuden:

            
Cross-Origin-Embedder-Policy: require-corp
Cross-Origin-Opener-Policy: same-origin

            

              
                Copy
              
            
          

Dessa huvuden isolerar din origin, vilket förhindrar informationsläckage mellan olika ursprung (cross-origin). Se till att din server är korrekt konfigurerad för att skicka dessa huvuden när den serverar JavaScript-kod som använder SharedArrayBuffer.

Alternativ till SharedArrayBuffer och Atomics

Även om SharedArrayBuffer och Atomics erbjuder kraftfulla verktyg för samtidig programmering, finns det andra tillvägagångssätt:

• Meddelandesändning: Använda asynkron meddelandesändning mellan Web Workers. Detta är ett mer traditionellt tillvägagångssätt men innebär kopiering av data mellan trådar.
• WebAssembly (WASM) trådar: WebAssembly stöder också delat minne och atomära operationer, vilket kan användas för att bygga högpresterande samtidiga applikationer.
• Service Workers: Även om de främst är för cachning och bakgrundsuppgifter, kan service workers också användas för samtidig bearbetning med hjälp av meddelandesändning.

Det bästa tillvägagångssättet beror på de specifika kraven för din applikation. SharedArrayBuffer och Atomics är mest lämpliga när du behöver dela stora mängder data mellan trådar med minimal overhead och strikt synkronisering.

Bästa praxis

• Håll det enkelt: Börja med enkla låsfria algoritmer och öka gradvis komplexiteten vid behov.
• Noggrann testning: Testa din samtidiga kod noggrant för att identifiera och åtgärda kapplöpningstillstånd och andra samtidighetsproblem.
• Kodgranskning: Låt din kod granskas av erfarna utvecklare som är bekanta med samtidig programmering.
• Använd prestandaprofilering: Använd verktyg för prestandaprofilering för att identifiera flaskhalsar och optimera din kod.
• Dokumentera din kod: Dokumentera din kod tydligt för att förklara designen och implementeringen av dina låsfria algoritmer.

Slutsats

SharedArrayBuffer och Atomics erbjuder en kraftfull mekanism för att bygga låsfria datastrukturer i JavaScript, vilket möjliggör effektiv samtidig programmering. Även om komplexiteten i att implementera låsfria algoritmer kan vara avskräckande, är de potentiella prestandafördelarna betydande för applikationer som kräver hög samtidighet och låg latens. I takt med att JavaScript fortsätter att utvecklas kommer dessa verktyg att bli allt viktigare för att bygga högpresterande, skalbara applikationer. Att anamma dessa tekniker, tillsammans med en stark förståelse för samtidighetsprinciper, ger utvecklare möjlighet att tänja på gränserna för JavaScript-prestanda i en värld med flera kärnor.

Ytterligare resurser för inlärning

• MDN Web Docs: SharedArrayBuffer
• MDN Web Docs: Atomics
• Artiklar om låsfria datastrukturer och algoritmer.
• Blogginlägg och artiklar om samtidig programmering i JavaScript.