Sammanhang

Det här dokumentet beskriver rollen för kontexter i Concurrency Runtime. En tråd som är kopplad till en schemaläggare kallas för en körningskontext, eller bara kontext. Med funktionen concurrency::wait och concurrency::Context kan du styra beteendet för kontexter. wait Använd funktionen för att pausa den aktuella kontexten under en angiven tid. Använd Context klassen för att få mer kontroll över när kontexter blockerar, avblockerar och ge plats, eller när du vill överbelasta den aktuella kontexten.

Väntefunktionen

Funktionen concurrency::wait samverkar för att pausa utförandet av den nuvarande kontexten under ett angivet antal millisekunder. Körningen använder avkastningstiden för att utföra andra uppgifter. När den angivna tiden har förflutit schemaläggs kontexten om för körning. wait Därför kan funktionen pausa den aktuella kontexten längre än det värde som anges för parameternmilliseconds.

Om du skickar 0 (noll) för parametern milliseconds pausas körningen av den aktuella kontexten tills alla andra aktiva kontexter ges möjlighet att utföra arbete. Så kan du överlåta en uppgift till alla andra aktiva uppgifter.

Exempel

Ett exempel som använder wait funktionen för att ge den aktuella kontexten och därmed tillåter att andra kontexter körs finns i How to: Use Schedule Groups to Influence Order of Execution (Så här använder du schemagrupper för att påverka körningsordningen).

Kontextklassen

Klassen concurrency::Context tillhandahåller en programmeringsabstraktion för en körningskontext och erbjuder två viktiga funktioner: möjligheten att tillsammans blockera, avblockera och ge den aktuella kontexten och möjligheten att överprenumerera den aktuella kontexten.

Samarbetsblockering

Med Context-klassen kan du blockera eller tillåta den aktuella exekveringskontexten. Blockering eller väntning används när den aktuella kontexten inte kan fortsätta eftersom en resurs inte är tillgänglig.

Metoden concurrency::Context::Block blockerar den aktuella kontexten. En kontext som är blockerad lämnar bearbetningsresurserna fri så att programkörningen kan utföra andra uppgifter. Metoden concurrency::Context::Unblock avblockeras en blockerad kontext. Metoden Context::Unblock måste anropas från en annan kontext än den som anropade Context::Block. Körningen genererar samtidighet::context_self_unblock om en kontext försöker avblockera sig själv.

Om du vill blockera och avblockera en kontext tillsammans anropar du vanligtvis samtidighet::Kontext::CurrentContext för att hämta en pekare till objektet Context som är associerat med den aktuella tråden och spara resultatet. Sedan anropar Context::Block du metoden för att blockera den aktuella kontexten. Context::Unblock Anropa senare från en separat kontext för att avblockera den blockerade kontexten.

Du måste matcha varje samtalspar till Context::Block och Context::Unblock. Körningen genererar samtidighet::context_unblock_unbalanced när metoden Context::Block eller Context::Unblock anropas konsekutivt utan ett matchande anrop till den andra metoden. Du behöver dock inte ringa Context::Block innan du anropar Context::Unblock. Om en kontext till exempel anropar Context::Unblock innan en annan kontext anropar Context::Block samma kontext förblir kontexten avblockerad.

Metoden concurrency::Context::Yield ger exekvering så att körningen kan utföra andra uppgifter och sedan schemalägga om kontexten för exekvering. När du anropar Context::Block metoden schemaläggs inte kontexten om.

Exempel

Ett exempel som använder Context::Blockmetoderna , Context::Unblockoch Context::Yield för att implementera en kooperativ semaforklass finns i Så här använder du kontextklassen för att implementera en kooperativ semafor.

Överprenumerering

Standardschemaläggaren skapar samma antal trådar som det finns tillgängliga maskinvarutrådar. Du kan använda överprenumerationer för att skapa ytterligare trådar för en viss maskinvarutråd.

För beräkningsintensiva åtgärder skalas vanligtvis inte överprenumerationen eftersom det medför ytterligare omkostnader. För uppgifter som har en hög svarstid, till exempel att läsa data från diskar eller från en nätverksanslutning, kan överprenumerationer dock förbättra den övergripande effektiviteten för vissa program.

Om du vill aktivera överprenumerering i den aktuella kontexten anropar du metoden concurrency::Context::Oversubscribe med parametern _BeginOversubscription inställd på true. När du aktiverar överprenumerering i en tråd som skapades av Concurrency Runtime, gör det att körningen skapar ytterligare en tråd. När alla uppgifter som kräver överprenumerering har slutförts anropar du Context::Oversubscribe med parametern _BeginOversubscription inställd på false.

Du kan aktivera överprenumerering flera gånger från den aktuella kontexten, men du måste inaktivera den samma antal gånger som du aktiverar den. Överprenumerering kan också kapslas. Det vill säga en uppgift som skapas av en annan uppgift som använder överprenumerering kan också överprenumerera sin kontext. Men om både en kapslad uppgift och dess överordnade uppgift tillhör samma sammanhang, är det bara det yttersta anropet till Context::Oversubscribe som medför att en ytterligare tråd skapas.

Exempel

Ett exempel som använder överprenumeration för att förskjuta svarstiden som orsakas av att läsa data från en nätverksanslutning finns i How to: Use Oversubscription to Offset Latency (Använda överprenumeration till förskjutningssvarstid).

Se även

Aktivitetsschemaläggare
Så här gör du: Använda schemagrupper för att påverka körordningen
Gör så här: Använda kontextklassen för att implementera en kooperativ semafor
Gör så här: Använd överprenumeration för att förskjuta svarstid