ReaderWriterLock Sınıf
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
Tek yazıcıları ve birden çok okuyucuları destekleyen bir kilit tanımlar.
public ref class ReaderWriterLock sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObjectpublic ref class ReaderWriterLock sealedpublic sealed class ReaderWriterLock : System.Runtime.ConstrainedExecution.CriticalFinalizerObjectpublic sealed class ReaderWriterLock[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ReaderWriterLock : System.Runtime.ConstrainedExecution.CriticalFinalizerObjecttype ReaderWriterLock = class
inherit CriticalFinalizerObjecttype ReaderWriterLock = class[<System.Runtime.InteropServices.ComVisible(true)>]
type ReaderWriterLock = class
inherit CriticalFinalizerObjectPublic NotInheritable Class ReaderWriterLock
Inherits CriticalFinalizerObjectPublic NotInheritable Class ReaderWriterLock- Devralma
- Devralma
-
ReaderWriterLock
- Öznitelikler
Aşağıdaki örnek, paylaşılan bir kaynağı korumak için eşzamanlı olarak okunan ve birden çok iş parçacığı tarafından özel olarak yazılan adlı resourcetamsayı değerinin nasıl kullanılacağını ReaderWriterLock gösterir.
ReaderWriterLock tüm iş parçacıklarına görünür olması için sınıf düzeyinde bildirildiğini unutmayın.
// This example shows a ReaderWriterLock protecting a shared
// resource that is read concurrently and written exclusively
// by multiple threads.
// The complete code is located in the ReaderWriterLock
// class topic.
using namespace System;
using namespace System::Threading;
public ref class Test
{
public:
// Declaring the ReaderWriterLock at the class level
// makes it visible to all threads.
static ReaderWriterLock^ rwl = gcnew ReaderWriterLock;
// For this example, the shared resource protected by the
// ReaderWriterLock is just an integer.
static int resource = 0;
literal int numThreads = 26;
static bool running = true;
// Statistics.
static int readerTimeouts = 0;
static int writerTimeouts = 0;
static int reads = 0;
static int writes = 0;
static void ThreadProc()
{
Random^ rnd = gcnew Random;
// As long as a thread runs, it randomly selects
// various ways to read and write from the shared
// resource. Each of the methods demonstrates one
// or more features of ReaderWriterLock.
while ( running )
{
double action = rnd->NextDouble();
if ( action < .8 )
ReadFromResource( 10 );
else
if ( action < .81 )
ReleaseRestore( rnd, 50 );
else
if ( action < .90 )
UpgradeDowngrade( rnd, 100 );
else
WriteToResource( rnd, 100 );
}
}
// Shows how to request and release a reader lock, and
// how to handle time-outs.
static void ReadFromResource( int timeOut )
{
try
{
rwl->AcquireReaderLock( timeOut );
try
{
// It is safe for this thread to read from
// the shared resource.
Display( String::Format( "reads resource value {0}", resource ) );
Interlocked::Increment( reads );
}
finally
{
// Ensure that the lock is released.
rwl->ReleaseReaderLock();
}
}
catch ( ApplicationException^ )
{
// The reader lock request timed out.
Interlocked::Increment( readerTimeouts );
}
}
// Shows how to request and release the writer lock, and
// how to handle time-outs.
static void WriteToResource( Random^ rnd, int timeOut )
{
try
{
rwl->AcquireWriterLock( timeOut );
try
{
// It is safe for this thread to read or write
// from the shared resource.
resource = rnd->Next( 500 );
Display( String::Format( "writes resource value {0}", resource ) );
Interlocked::Increment( writes );
}
finally
{
// Ensure that the lock is released.
rwl->ReleaseWriterLock();
}
}
catch ( ApplicationException^ )
{
// The writer lock request timed out.
Interlocked::Increment( writerTimeouts );
}
}
// Shows how to request a reader lock, upgrade the
// reader lock to the writer lock, and downgrade to a
// reader lock again.
static void UpgradeDowngrade( Random^ rnd, int timeOut )
{
try
{
rwl->AcquireReaderLock( timeOut );
try
{
// It is safe for this thread to read from
// the shared resource.
Display( String::Format( "reads resource value {0}", resource ) );
Interlocked::Increment( reads );
// If it is necessary to write to the resource,
// you must either release the reader lock and
// then request the writer lock, or upgrade the
// reader lock. Note that upgrading the reader lock
// puts the thread in the write queue, behind any
// other threads that might be waiting for the
// writer lock.
try
{
LockCookie lc = rwl->UpgradeToWriterLock( timeOut );
try
{
// It is safe for this thread to read or write
// from the shared resource.
resource = rnd->Next( 500 );
Display( String::Format( "writes resource value {0}", resource ) );
Interlocked::Increment( writes );
}
finally
{
// Ensure that the lock is released.
rwl->DowngradeFromWriterLock( lc );
}
}
catch ( ApplicationException^ )
{
// The upgrade request timed out.
Interlocked::Increment( writerTimeouts );
}
// When the lock has been downgraded, it is
// still safe to read from the resource.
Display( String::Format( "reads resource value {0}", resource ) );
Interlocked::Increment( reads );
}
finally
{
// Ensure that the lock is released.
rwl->ReleaseReaderLock();
}
}
catch ( ApplicationException^ )
{
// The reader lock request timed out.
Interlocked::Increment( readerTimeouts );
}
}
// Shows how to release all locks and later restore
// the lock state. Shows how to use sequence numbers
// to determine whether another thread has obtained
// a writer lock since this thread last accessed the
// resource.
static void ReleaseRestore( Random^ rnd, int timeOut )
{
int lastWriter;
try
{
rwl->AcquireReaderLock( timeOut );
try
{
// It is safe for this thread to read from
// the shared resource. Cache the value. (You
// might do this if reading the resource is
// an expensive operation.)
int resourceValue = resource;
Display( String::Format( "reads resource value {0}", resourceValue ) );
Interlocked::Increment( reads );
// Save the current writer sequence number.
lastWriter = rwl->WriterSeqNum;
// Release the lock, and save a cookie so the
// lock can be restored later.
LockCookie lc = rwl->ReleaseLock();
// Wait for a random interval (up to a
// quarter of a second), and then restore
// the previous state of the lock. Note that
// there is no timeout on the Restore method.
Thread::Sleep( rnd->Next( 250 ) );
rwl->RestoreLock( lc );
// Check whether other threads obtained the
// writer lock in the interval. If not, then
// the cached value of the resource is still
// valid.
if ( rwl->AnyWritersSince( lastWriter ) )
{
resourceValue = resource;
Interlocked::Increment( reads );
Display( String::Format( "resource has changed {0}", resourceValue ) );
}
else
{
Display( String::Format( "resource has not changed {0}", resourceValue ) );
}
}
finally
{
// Ensure that the lock is released.
rwl->ReleaseReaderLock();
}
}
catch ( ApplicationException^ )
{
// The reader lock request timed out.
Interlocked::Increment( readerTimeouts );
}
}
// Helper method briefly displays the most recent
// thread action. Comment out calls to Display to
// get a better idea of throughput.
static void Display( String^ msg )
{
Console::Write( "Thread {0} {1}. \r", Thread::CurrentThread->Name, msg );
}
};
int main()
{
array<String^>^args = Environment::GetCommandLineArgs();
// Start a series of threads. Each thread randomly
// performs reads and writes on the shared resource.
array<Thread^>^t = gcnew array<Thread^>(Test::numThreads);
for ( int i = 0; i < Test::numThreads; i++ )
{
t[ i ] = gcnew Thread( gcnew ThreadStart( Test::ThreadProc ) );
t[ i ]->Name = gcnew String( Convert::ToChar( i + 65 ),1 );
t[ i ]->Start();
if ( i > 10 )
Thread::Sleep( 300 );
}
// Tell the threads to shut down, then wait until they all
// finish.
Test::running = false;
for ( int i = 0; i < Test::numThreads; i++ )
{
t[ i ]->Join();
}
// Display statistics.
Console::WriteLine( "\r\n {0} reads, {1} writes, {2} reader time-outs, {3} writer time-outs.", Test::reads, Test::writes, Test::readerTimeouts, Test::writerTimeouts );
Console::WriteLine( "Press ENTER to exit." );
Console::ReadLine();
return 0;
}
// The complete code is located in the ReaderWriterLock class topic.
using System;
using System.Threading;
public class Example
{
static ReaderWriterLock rwl = new ReaderWriterLock();
// Define the shared resource protected by the ReaderWriterLock.
static int resource = 0;
const int numThreads = 26;
static bool running = true;
// Statistics.
static int readerTimeouts = 0;
static int writerTimeouts = 0;
static int reads = 0;
static int writes = 0;
public static void Main()
{
// Start a series of threads to randomly read from and
// write to the shared resource.
Thread[] t = new Thread[numThreads];
for (int i = 0; i < numThreads; i++){
t[i] = new Thread(new ThreadStart(ThreadProc));
t[i].Name = new String((char)(i + 65), 1);
t[i].Start();
if (i > 10)
Thread.Sleep(300);
}
// Tell the threads to shut down and wait until they all finish.
running = false;
for (int i = 0; i < numThreads; i++)
t[i].Join();
// Display statistics.
Console.WriteLine("\n{0} reads, {1} writes, {2} reader time-outs, {3} writer time-outs.",
reads, writes, readerTimeouts, writerTimeouts);
Console.Write("Press ENTER to exit... ");
Console.ReadLine();
}
static void ThreadProc()
{
Random rnd = new Random();
// Randomly select a way for the thread to read and write from the shared
// resource.
while (running) {
double action = rnd.NextDouble();
if (action < .8)
ReadFromResource(10);
else if (action < .81)
ReleaseRestore(rnd, 50);
else if (action < .90)
UpgradeDowngrade(rnd, 100);
else
WriteToResource(rnd, 100);
}
}
// Request and release a reader lock, and handle time-outs.
static void ReadFromResource(int timeOut)
{
try {
rwl.AcquireReaderLock(timeOut);
try {
// It is safe for this thread to read from the shared resource.
Display("reads resource value " + resource);
Interlocked.Increment(ref reads);
}
finally {
// Ensure that the lock is released.
rwl.ReleaseReaderLock();
}
}
catch (ApplicationException) {
// The reader lock request timed out.
Interlocked.Increment(ref readerTimeouts);
}
}
// Request and release the writer lock, and handle time-outs.
static void WriteToResource(Random rnd, int timeOut)
{
try {
rwl.AcquireWriterLock(timeOut);
try {
// It's safe for this thread to access from the shared resource.
resource = rnd.Next(500);
Display("writes resource value " + resource);
Interlocked.Increment(ref writes);
}
finally {
// Ensure that the lock is released.
rwl.ReleaseWriterLock();
}
}
catch (ApplicationException) {
// The writer lock request timed out.
Interlocked.Increment(ref writerTimeouts);
}
}
// Requests a reader lock, upgrades the reader lock to the writer
// lock, and downgrades it to a reader lock again.
static void UpgradeDowngrade(Random rnd, int timeOut)
{
try {
rwl.AcquireReaderLock(timeOut);
try {
// It's safe for this thread to read from the shared resource.
Display("reads resource value " + resource);
Interlocked.Increment(ref reads);
// To write to the resource, either release the reader lock and
// request the writer lock, or upgrade the reader lock. Upgrading
// the reader lock puts the thread in the write queue, behind any
// other threads that might be waiting for the writer lock.
try {
LockCookie lc = rwl.UpgradeToWriterLock(timeOut);
try {
// It's safe for this thread to read or write from the shared resource.
resource = rnd.Next(500);
Display("writes resource value " + resource);
Interlocked.Increment(ref writes);
}
finally {
// Ensure that the lock is released.
rwl.DowngradeFromWriterLock(ref lc);
}
}
catch (ApplicationException) {
// The upgrade request timed out.
Interlocked.Increment(ref writerTimeouts);
}
// If the lock was downgraded, it's still safe to read from the resource.
Display("reads resource value " + resource);
Interlocked.Increment(ref reads);
}
finally {
// Ensure that the lock is released.
rwl.ReleaseReaderLock();
}
}
catch (ApplicationException) {
// The reader lock request timed out.
Interlocked.Increment(ref readerTimeouts);
}
}
// Release all locks and later restores the lock state.
// Uses sequence numbers to determine whether another thread has
// obtained a writer lock since this thread last accessed the resource.
static void ReleaseRestore(Random rnd, int timeOut)
{
int lastWriter;
try {
rwl.AcquireReaderLock(timeOut);
try {
// It's safe for this thread to read from the shared resource,
// so read and cache the resource value.
int resourceValue = resource; // Cache the resource value.
Display("reads resource value " + resourceValue);
Interlocked.Increment(ref reads);
// Save the current writer sequence number.
lastWriter = rwl.WriterSeqNum;
// Release the lock and save a cookie so the lock can be restored later.
LockCookie lc = rwl.ReleaseLock();
// Wait for a random interval and then restore the previous state of the lock.
Thread.Sleep(rnd.Next(250));
rwl.RestoreLock(ref lc);
// Check whether other threads obtained the writer lock in the interval.
// If not, then the cached value of the resource is still valid.
if (rwl.AnyWritersSince(lastWriter)) {
resourceValue = resource;
Interlocked.Increment(ref reads);
Display("resource has changed " + resourceValue);
}
else {
Display("resource has not changed " + resourceValue);
}
}
finally {
// Ensure that the lock is released.
rwl.ReleaseReaderLock();
}
}
catch (ApplicationException) {
// The reader lock request timed out.
Interlocked.Increment(ref readerTimeouts);
}
}
// Helper method briefly displays the most recent thread action.
static void Display(string msg)
{
Console.Write("Thread {0} {1}. \r", Thread.CurrentThread.Name, msg);
}
}
' The complete code is located in the ReaderWriterLock class topic.
Imports System.Threading
Public Module Example
Private rwl As New ReaderWriterLock()
' Define the shared resource protected by the ReaderWriterLock.
Private resource As Integer = 0
Const numThreads As Integer = 26
Private running As Boolean = True
' Statistics.
Private readerTimeouts As Integer = 0
Private writerTimeouts As Integer = 0
Private reads As Integer = 0
Private writes As Integer = 0
Public Sub Main()
' Start a series of threads to randomly read from and
' write to the shared resource.
Dim t(numThreads - 1) As Thread
Dim i As Integer
For i = 0 To numThreads - 1
t(i) = New Thread(New ThreadStart(AddressOf ThreadProc))
t(i).Name = Chr(i + 65)
t(i).Start()
If i > 10 Then
Thread.Sleep(300)
End If
Next
' Tell the threads to shut down and wait until they all finish.
running = False
For i = 0 To numThreads - 1
t(i).Join()
Next
' Display statistics.
Console.WriteLine(vbCrLf & "{0} reads, {1} writes, {2} reader time-outs, {3} writer time-outs.",
reads, writes, readerTimeouts, writerTimeouts)
Console.Write("Press ENTER to exit... ")
Console.ReadLine()
End Sub
Sub ThreadProc()
Dim rnd As New Random
' Randomly select a way for the thread to read and write from the shared
' resource.
While running
Dim action As Double = rnd.NextDouble()
If action < 0.8 Then
ReadFromResource(10)
ElseIf action < 0.81 Then
ReleaseRestore(rnd, 50)
ElseIf action < 0.9 Then
UpgradeDowngrade(rnd, 100)
Else
WriteToResource(rnd, 100)
End If
End While
End Sub
' Request and release a reader lock, and handle time-outs.
Sub ReadFromResource(timeOut As Integer)
Try
rwl.AcquireReaderLock(timeOut)
Try
' It's safe for this thread to read from the shared resource.
Display("reads resource value " & resource)
Interlocked.Increment(reads)
Finally
' Ensure that the lock is released.
rwl.ReleaseReaderLock()
End Try
Catch ex As ApplicationException
' The reader lock request timed out.
Interlocked.Increment(readerTimeouts)
End Try
End Sub
' Request and release the writer lock, and handle time-outs.
Sub WriteToResource(rnd As Random, timeOut As Integer)
Try
rwl.AcquireWriterLock(timeOut)
Try
' It's safe for this thread to read or write from the shared resource.
resource = rnd.Next(500)
Display("writes resource value " & resource)
Interlocked.Increment(writes)
Finally
' Ensure that the lock is released.
rwl.ReleaseWriterLock()
End Try
Catch ex As ApplicationException
' The writer lock request timed out.
Interlocked.Increment(writerTimeouts)
End Try
End Sub
' Requests a reader lock, upgrades the reader lock to the writer
' lock, and downgrades it to a reader lock again.
Sub UpgradeDowngrade(rnd As Random, timeOut As Integer)
Try
rwl.AcquireReaderLock(timeOut)
Try
' It's safe for this thread to read from the shared resource.
Display("reads resource value " & resource)
Interlocked.Increment(reads)
' To write to the resource, either release the reader lock and
' request the writer lock, or upgrade the reader lock. Upgrading
' the reader lock puts the thread in the write queue, behind any
' other threads that might be waiting for the writer lock.
Try
Dim lc As LockCookie = rwl.UpgradeToWriterLock(timeOut)
Try
' It's safe for this thread to read or write from the shared resource.
resource = rnd.Next(500)
Display("writes resource value " & resource)
Interlocked.Increment(writes)
Finally
' Ensure that the lock is released.
rwl.DowngradeFromWriterLock(lc)
End Try
Catch ex As ApplicationException
' The upgrade request timed out.
Interlocked.Increment(writerTimeouts)
End Try
' If the lock was downgraded, it's still safe to read from the resource.
Display("reads resource value " & resource)
Interlocked.Increment(reads)
Finally
' Ensure that the lock is released.
rwl.ReleaseReaderLock()
End Try
Catch ex As ApplicationException
' The reader lock request timed out.
Interlocked.Increment(readerTimeouts)
End Try
End Sub
' Release all locks and later restores the lock state.
' Uses sequence numbers to determine whether another thread has
' obtained a writer lock since this thread last accessed the resource.
Sub ReleaseRestore(rnd As Random ,timeOut As Integer)
Dim lastWriter As Integer
Try
rwl.AcquireReaderLock(timeOut)
Try
' It's safe for this thread to read from the shared resource,
' so read and cache the resource value.
Dim resourceValue As Integer = resource
Display("reads resource value " & resourceValue)
Interlocked.Increment(reads)
' Save the current writer sequence number.
lastWriter = rwl.WriterSeqNum
' Release the lock and save a cookie so the lock can be restored later.
Dim lc As LockCookie = rwl.ReleaseLock()
' Wait for a random interval and then restore the previous state of the lock.
Thread.Sleep(rnd.Next(250))
rwl.RestoreLock(lc)
' Check whether other threads obtained the writer lock in the interval.
' If not, then the cached value of the resource is still valid.
If rwl.AnyWritersSince(lastWriter) Then
resourceValue = resource
Interlocked.Increment(reads)
Display("resource has changed " & resourceValue)
Else
Display("resource has not changed " & resourceValue)
End If
Finally
' Ensure that the lock is released.
rwl.ReleaseReaderLock()
End Try
Catch ex As ApplicationException
' The reader lock request timed out.
Interlocked.Increment(readerTimeouts)
End Try
End Sub
' Helper method briefly displays the most recent thread action.
Sub Display(msg As String)
Console.Write("Thread {0} {1}. " & vbCr, Thread.CurrentThread.Name, msg)
End Sub
End Module
Önemli
.NET Framework iki okuyucu yazıcı kilidi vardır ReaderWriterLockSlim ve ReaderWriterLock. ReaderWriterLockSlim tüm yeni geliştirmeler için önerilir. ReaderWriterLockSlim ile benzerdir ReaderWriterLock, ancak özyineleme ve kilit durumunu yükseltme ve düşürme için basitleştirilmiş kuralları vardır. ReaderWriterLockSlim olası kilitlenme durumlarını önler. Buna ek olarak, performansı değerinden ReaderWriterLockSlim önemli ölçüde daha ReaderWriterLockiyidir.
ReaderWriterLock bir kaynağa erişimi eşitlemek için kullanılır. Herhangi bir zamanda, birden çok iş parçacığı için eşzamanlı okuma erişimine veya tek bir iş parçacığı için yazma erişimine izin verir. Bir kaynağın seyrek olarak değiştirildiği bir durumda, ReaderWriterLock gibi tek seferde basit bir kilitten Monitordaha iyi aktarım hızı sağlar.
ReaderWriterLock çoğu erişimin okunduğu, yazma işlemlerinin ise seyrek ve kısa süreli olduğu durumlarda en iyi sonucu verir. Birden çok okuyucu tek yazıcılarla birlikte alternatif olarak, okuyucuların veya yazarların uzun süreler boyunca engellenmemesi için.
Not
Okuyucu kilitlerini veya yazıcı kilitlerini uzun süre tutmak diğer iş parçacıklarını aç bırakacaktır. En iyi performans için, yazma işlemlerinin süresini en aza indirmek için uygulamanızı yeniden yapılandırmayı göz önünde bulundurun.
bir iş parçacığı bir okuyucu kilidini veya yazıcı kilidini tutabilir, ancak aynı anda ikisini birden tutamaz. Yazıcı kilidini almak için bir okuyucu kilidi bırakmak yerine ve DowngradeFromWriterLockkullanabilirsinizUpgradeToWriterLock.
Özyinelemeli kilit istekleri, kilit üzerindeki kilit sayısını artırır.
Okuyucular ve yazarlar ayrı ayrı kuyruğa alınıyor. Bir iş parçacığı yazıcı kilidini serbest bıraktığında, o anda okuyucu kuyruğunda bekleyen tüm iş parçacıklarına okuyucu kilitleri verilir; Tüm bu okuyucu kilitleri serbest bırakıldığında, varsa yazıcı kuyruğunda bekleyen bir sonraki iş parçacığına yazıcı kilidi verilir ve bu şekilde devam eder. Başka bir deyişle, ReaderWriterLock bir okuyucu koleksiyonu ile bir yazar arasında geçiş sağlar.
Yazıcı kuyruğundaki bir iş parçacığı etkin okuyucu kilitlerinin yayımlanmasını beklerken, yeni okuyucu kilitleri isteyen iş parçacıkları okuyucu kuyruğunda birikir. Mevcut okuyucu kilidi sahipleriyle eşzamanlı erişim paylaşabilseler bile istekleri verilmez; bu, yazarların okuyucular tarafından süresiz engellenmesine karşı korunmasına yardımcı olur.
Kabul edilen zaman aşımı değerlerinde ReaderWriterLock kilit alma yöntemlerinin çoğu. Uygulamanızda kilitlenmeleri önlemek için zaman aşımlarını kullanın. Örneğin, bir iş parçacığı bir kaynakta yazıcı kilidini alabilir ve ardından ikinci bir kaynakta okuyucu kilidi isteyebilir; bu arada, başka bir iş parçacığı ikinci kaynakta yazıcı kilidini alabilir ve ilkinde bir okuyucu kilidi isteyebilir. Zaman aşımları kullanılmadığı sürece iş parçacıkları kilitlenmez.
Zaman aşımı aralığının süresi dolarsa ve kilit isteği verilmediyse, yöntemi bir ApplicationExceptionoluşturarak denetimi çağıran iş parçacığına döndürür. bir iş parçacığı bu özel durumu yakalayabilir ve bundan sonra hangi eylemin gerçekleştirileceğini belirleyebilir.
Zaman aşımları milisaniye cinsinden ifade edilir. Zaman aşımını belirtmek için bir System.TimeSpan kullanırsanız, kullanılan değer ile TimeSpantemsil edilen toplam milisaniye sayısıdır. Aşağıdaki tabloda geçerli zaman aşımı değerleri milisaniye cinsinden gösterilmektedir.
| Değer | Açıklama |
|---|---|
| -1 | İş parçacığı, ne kadar sürdüğüne bakılmaksızın kilit alınana kadar bekler. Tamsayı zaman aşımlarını belirten yöntemler için sabit Infinite kullanılabilir. |
| 0 | İş parçacığı kilidi almak için beklemez. Kilit hemen alınamazsa, yöntem döndürür. |
| >0 | Beklenen milisaniye sayısı. |
-1 dışında, negatif zaman aşımı değerlerine izin verilmez. -1 dışında bir negatif tamsayı belirtirseniz, bunun yerine sıfır zaman aşımı değeri kullanılır. (Yani, kilit hemen alınamazsa yöntem beklemeden döner.) -1 dışında negatif bir milisaniye sayısını temsil eden bir TimeSpan belirtirseniz, ArgumentOutOfRangeException oluşturulur.
|
Reader |
ReaderWriterLock sınıfının yeni bir örneğini başlatır. |
|
Is |
Geçerli iş parçacığının okuyucu kilidi barındırıp tutmadığını belirten bir değer alır. |
|
Is |
Geçerli iş parçacığının yazıcı kilidini barındırıp tutmadığını belirten bir değer alır. |
|
Writer |
Geçerli sıra numarasını alır. |
|
Acquire |
Zaman aşımı için bir değer kullanarak bir Int32 okuyucu kilidi alır. |
|
Acquire |
Zaman aşımı için bir değer kullanarak bir TimeSpan okuyucu kilidi alır. |
|
Acquire |
Zaman aşımı için bir Int32 değer kullanarak yazıcı kilidini alır. |
|
Acquire |
Zaman aşımı için bir TimeSpan değer kullanarak yazıcı kilidini alır. |
|
Any |
Sıra numarası elde edildikten sonra yazıcı kilidinin herhangi bir iş parçacığına verilip verilmediğini gösterir. |
|
Downgrade |
İş parçacığının kilit durumunu daha önce UpgradeToWriterLock(Int32) çağrıldığı duruma geri yükler. |
| Equals(Object) |
Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object) |
| Finalize() |
Atık toplayıcı nesneyi geri kazandığında kaynakların serbest kalmasını ve diğer temizleme işlemlerinin gerçekleştirilmesini ReaderWriterLock sağlar. |
|
Get |
Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object) |
|
Get |
Type Geçerli örneğini alır. (Devralındığı yer: Object) |
|
Memberwise |
Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object) |
|
Release |
İş parçacığının kilidi kaç kez aldığına bakılmaksızın kilidi serbest bırakır. |
|
Release |
Kilit sayısını azaltma. |
|
Release |
Yazıcı kilidindeki kilit sayısını azaltma. |
|
Restore |
İş parçacığının kilit durumunu çağırmadan ReleaseLock()önceki durumuna geri yükler. |
|
To |
Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object) |
|
Upgrade |
Zaman aşımı için bir Int32 değer kullanarak okuyucu kilidini yazıcı kilidine yükselter. |
|
Upgrade |
Zaman aşımı için bir |
| Ürün | Sürümler |
|---|---|
| .NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 2.0, 2.1 |
Bu güvenli iş parçacığı türüdür.
.NET geri bildirimi
.NET, açık kaynak bir projedir. Geri bildirim sağlamak için bir bağlantı seçin: