Semaphore Kelas

Definisi

Ruang nama:

System.Threading

Rakitan:

System.Threading.dll

Sumber:

Semaphore.cs

Membatasi jumlah utas yang dapat mengakses sumber daya atau kumpulan sumber daya secara bersamaan.

public ref class Semaphore sealed : System::Threading::WaitHandle

public sealed class Semaphore : System.Threading.WaitHandle

type Semaphore = class
    inherit WaitHandle

Public NotInheritable Class Semaphore
Inherits WaitHandle

Warisan

Object

MarshalByRefObject

WaitHandle

Semaphore

Contoh

Contoh kode berikut membuat semaphore dengan jumlah maksimum tiga dan jumlah awal nol. Contohnya memulai lima utas, yang memblokir menunggu semaphore. Utas Release(Int32) utama menggunakan metode kelebihan beban untuk meningkatkan jumlah semaphore hingga maksimumnya, memungkinkan tiga utas memasuki semaphore. Setiap utas Thread.Sleep menggunakan metode untuk menunggu satu detik, untuk mensimulasikan pekerjaan, lalu memanggil Release() metode kelebihan beban untuk melepaskan semaphore. Setiap kali semaphore dirilis, jumlah semaphore sebelumnya ditampilkan. Pesan konsol melacak penggunaan semaphore. Interval kerja yang disimulasikan sedikit ditingkatkan untuk setiap utas, untuk membuat output lebih mudah dibaca.

#using <System.dll>
using namespace System;
using namespace System::Threading;

public ref class Example
{
private:
   // A semaphore that simulates a limited resource pool.
   //
   static Semaphore^ _pool;

   // A padding interval to make the output more orderly.
   static int _padding;

public:
   static void Main()
   {
      // Create a semaphore that can satisfy up to three
      // concurrent requests. Use an initial count of zero,
      // so that the entire semaphore count is initially
      // owned by the main program thread.
      //
      _pool = gcnew Semaphore( 0,3 );
      
      // Create and start five numbered threads.
      //
      for ( int i = 1; i <= 5; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew ParameterizedThreadStart( Worker ) );
         
         // Start the thread, passing the number.
         //
         t->Start( i );
      }
      
      // Wait for half a second, to allow all the
      // threads to start and to block on the semaphore.
      //
      Thread::Sleep( 500 );
      
      // The main thread starts out holding the entire
      // semaphore count. Calling Release(3) brings the
      // semaphore count back to its maximum value, and
      // allows the waiting threads to enter the semaphore,
      // up to three at a time.
      //
      Console::WriteLine( L"Main thread calls Release(3)." );
      _pool->Release( 3 );

      Console::WriteLine( L"Main thread exits." );
   }

private:
   static void Worker( Object^ num )
   {
      // Each worker thread begins by requesting the
      // semaphore.
      Console::WriteLine( L"Thread {0} begins and waits for the semaphore.", num );
      _pool->WaitOne();
      
      // A padding interval to make the output more orderly.
      int padding = Interlocked::Add( _padding, 100 );

      Console::WriteLine( L"Thread {0} enters the semaphore.", num );
      
      // The thread's "work" consists of sleeping for
      // about a second. Each thread "works" a little
      // longer, just to make the output more orderly.
      //
      Thread::Sleep( 1000 + padding );

      Console::WriteLine( L"Thread {0} releases the semaphore.", num );
      Console::WriteLine( L"Thread {0} previous semaphore count: {1}",
         num, _pool->Release() );
   }
};

using System;
using System.Threading;

public class Example
{
    // A semaphore that simulates a limited resource pool.
    //
    private static Semaphore _pool;

    // A padding interval to make the output more orderly.
    private static int _padding;

    public static void Main()
    {
        // Create a semaphore that can satisfy up to three
        // concurrent requests. Use an initial count of zero,
        // so that the entire semaphore count is initially
        // owned by the main program thread.
        //
        _pool = new Semaphore(initialCount: 0, maximumCount: 3);

        // Create and start five numbered threads. 
        //
        for(int i = 1; i <= 5; i++)
        {
            Thread t = new Thread(new ParameterizedThreadStart(Worker));

            // Start the thread, passing the number.
            //
            t.Start(i);
        }

        // Wait for half a second, to allow all the
        // threads to start and to block on the semaphore.
        //
        Thread.Sleep(500);

        // The main thread starts out holding the entire
        // semaphore count. Calling Release(3) brings the 
        // semaphore count back to its maximum value, and
        // allows the waiting threads to enter the semaphore,
        // up to three at a time.
        //
        Console.WriteLine("Main thread calls Release(3).");
        _pool.Release(releaseCount: 3);

        Console.WriteLine("Main thread exits.");
    }

    private static void Worker(object num)
    {
        // Each worker thread begins by requesting the
        // semaphore.
        Console.WriteLine("Thread {0} begins " +
            "and waits for the semaphore.", num);
        _pool.WaitOne();

        // A padding interval to make the output more orderly.
        int padding = Interlocked.Add(ref _padding, 100);

        Console.WriteLine("Thread {0} enters the semaphore.", num);
        
        // The thread's "work" consists of sleeping for 
        // about a second. Each thread "works" a little 
        // longer, just to make the output more orderly.
        //
        Thread.Sleep(1000 + padding);

        Console.WriteLine("Thread {0} releases the semaphore.", num);
        Console.WriteLine("Thread {0} previous semaphore count: {1}",
            num, _pool.Release());
    }
}

Imports System.Threading

Public Class Example

    ' A semaphore that simulates a limited resource pool.
    '
    Private Shared _pool As Semaphore

    ' A padding interval to make the output more orderly.
    Private Shared _padding As Integer

    <MTAThread> _
    Public Shared Sub Main()
        ' Create a semaphore that can satisfy up to three
        ' concurrent requests. Use an initial count of zero,
        ' so that the entire semaphore count is initially
        ' owned by the main program thread.
        '
        _pool = New Semaphore(0, 3)

        ' Create and start five numbered threads. 
        '
        For i As Integer = 1 To 5
            Dim t As New Thread(New ParameterizedThreadStart(AddressOf Worker))
            'Dim t As New Thread(AddressOf Worker)

            ' Start the thread, passing the number.
            '
            t.Start(i)
        Next i

        ' Wait for half a second, to allow all the
        ' threads to start and to block on the semaphore.
        '
        Thread.Sleep(500)

        ' The main thread starts out holding the entire
        ' semaphore count. Calling Release(3) brings the 
        ' semaphore count back to its maximum value, and
        ' allows the waiting threads to enter the semaphore,
        ' up to three at a time.
        '
        Console.WriteLine("Main thread calls Release(3).")
        _pool.Release(3)

        Console.WriteLine("Main thread exits.")
    End Sub

    Private Shared Sub Worker(ByVal num As Object)
        ' Each worker thread begins by requesting the
        ' semaphore.
        Console.WriteLine("Thread {0} begins " _
            & "and waits for the semaphore.", num)
        _pool.WaitOne()

        ' A padding interval to make the output more orderly.
        Dim padding As Integer = Interlocked.Add(_padding, 100)

        Console.WriteLine("Thread {0} enters the semaphore.", num)
        
        ' The thread's "work" consists of sleeping for 
        ' about a second. Each thread "works" a little 
        ' longer, just to make the output more orderly.
        '
        Thread.Sleep(1000 + padding)

        Console.WriteLine("Thread {0} releases the semaphore.", num)
        Console.WriteLine("Thread {0} previous semaphore count: {1}", _
            num, _
            _pool.Release())
    End Sub
End Class

Keterangan

Semaphore Gunakan kelas untuk mengontrol akses ke kumpulan sumber daya. Utas memasuki semaphore dengan memanggil WaitOne metode , yang diwarisi dari WaitHandle kelas , dan melepaskan semaphore dengan memanggil Release metode .

Hitungan pada semaphore direkrementasi setiap kali utas memasuki semaphore, dan bertambah ketika utas melepaskan semaphore. Ketika jumlahnya nol, permintaan berikutnya memblokir hingga utas lain melepaskan semaphore. Ketika semua utas telah merilis semaphore, hitungannya adalah pada nilai maksimum yang ditentukan ketika semaphore dibuat.

Tidak ada urutan yang dijamin, seperti FIFO atau LIFO, di mana utas yang diblokir memasuki semaphore.

Utas dapat memasuki semaphore beberapa kali, dengan memanggil WaitOne metode berulang kali. Untuk merilis beberapa atau semua entri ini, utas dapat memanggil metode tanpa Release() parameter kelebihan beban beberapa kali, atau dapat memanggil Release(Int32) metode kelebihan beban yang menentukan jumlah entri yang akan dirilis.

Kelas Semaphore tidak memberlakukan identitas utas pada panggilan ke WaitOne atau Release. Programmer bertanggung jawab untuk memastikan bahwa utas tidak melepaskan semaphore terlalu banyak kali. Misalnya, bila semaphore memiliki jumlah maksimum dua, dan utas A dan utas B keduanya memasuki semaphore tersebut. Jika kesalahan pemrograman di utas B menyebabkannya memanggil Release dua kali, maka kedua panggilan berhasil. Hitungan pada semaphore penuh, dan ketika utas A akhirnya memanggil Release, maka SemaphoreFullException dilemparkan.

Semaphores terdiri dari dua jenis: semaphores lokal dan semaphores sistem bernama. Jika Anda membuat Semaphore objek menggunakan konstruktor yang menerima nama, objek tersebut dikaitkan dengan semaphore sistem operasi dari nama tersebut. Semafor sistem bernama terlihat di seluruh sistem operasi, dan dapat digunakan untuk menyinkronkan aktivitas proses. Anda dapat membuat beberapa Semaphore objek yang mewakili semaphore sistem bernama yang sama, dan Anda dapat menggunakan OpenExisting metode untuk membuka semaphore sistem bernama yang ada.

Semaphore lokal hanya ada dalam proses Anda. Mutex ini dapat digunakan oleh utas apa pun dalam proses Anda yang memiliki referensi ke objek Semaphore lokal. Setiap Semaphore objek adalah semaphore lokal terpisah.

Perhatian

Secara default, semaphore bernama tidak dibatasi untuk pengguna yang membuatnya. Pengguna lain mungkin dapat membuka dan menggunakan semaphore, termasuk mengganggu semaphore dengan memperoleh semaphore beberapa kali dan tidak merilisnya. Untuk membatasi akses ke pengguna tertentu, Anda dapat menggunakan kelebihan beban konstruktor atau SemaphoreAcl dan meneruskan SemaphoreSecurity saat membuat semaphore bernama. Hindari menggunakan semaphores bernama tanpa pembatasan akses pada sistem yang mungkin memiliki pengguna yang tidak tepercaya yang menjalankan kode.

Konstruktor

Semaphore(Int32, Int32)	Menginisialisasi instans Semaphore baru kelas , menentukan jumlah awal entri dan jumlah maksimum entri bersamaan.
Semaphore(Int32, Int32, String)	Menginisialisasi instans Semaphore baru kelas , menentukan jumlah awal entri dan jumlah maksimum entri bersamaan, dan secara opsional menentukan nama objek semaphore sistem.
Semaphore(Int32, Int32, String, Boolean)	Menginisialisasi instans Semaphore baru kelas , menentukan jumlah awal entri dan jumlah maksimum entri bersamaan, secara opsional menentukan nama objek semaphore sistem, dan menentukan variabel yang menerima nilai yang menunjukkan apakah semaphore sistem baru dibuat.

Bidang

WaitTimeout

Menunjukkan bahwa operasi kehabisan WaitAny(WaitHandle[], Int32, Boolean) waktu sebelum salah satu handel tunggu diberi sinyal. Bidang ini konstan. (Diperoleh dari WaitHandle)

Properti

Handle	Kedaluwarsa. Mendapatkan atau mengatur handel sistem operasi asli. (Diperoleh dari WaitHandle)
SafeWaitHandle	Mendapatkan atau mengatur handel sistem operasi asli. (Diperoleh dari WaitHandle)

Metode

Close()	Merilis semua sumber daya yang dipegang oleh saat ini WaitHandle. (Diperoleh dari WaitHandle)
CreateObjRef(Type)	Membuat objek yang berisi semua informasi relevan yang diperlukan untuk menghasilkan proksi yang digunakan untuk berkomunikasi dengan objek jarak jauh. (Diperoleh dari MarshalByRefObject)
Dispose()	Merilis semua sumber daya yang digunakan oleh instans WaitHandle kelas saat ini. (Diperoleh dari WaitHandle)
Dispose(Boolean)	Ketika ditimpa di kelas turunan, merilis sumber daya tidak terkelola yang digunakan oleh WaitHandle, dan secara opsional merilis sumber daya terkelola. (Diperoleh dari WaitHandle)
Equals(Object)	Menentukan apakah objek yang ditentukan sama dengan objek saat ini. (Diperoleh dari Object)
GetHashCode()	Berfungsi sebagai fungsi hash default. (Diperoleh dari Object)
GetLifetimeService()	Kedaluwarsa. Mengambil objek layanan seumur hidup saat ini yang mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject)
GetType()	Mendapatkan dari instans Type saat ini. (Diperoleh dari Object)
InitializeLifetimeService()	Kedaluwarsa. Mendapatkan objek layanan seumur hidup untuk mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject)
MemberwiseClone()	Membuat salinan dangkal dari saat ini Object. (Diperoleh dari Object)
MemberwiseClone(Boolean)	Membuat salinan dangkal objek saat ini MarshalByRefObject . (Diperoleh dari MarshalByRefObject)
OpenExisting(String)	Membuka semaphore bernama yang ditentukan, jika sudah ada.
Release()	Keluar dari semaphore dan mengembalikan hitungan sebelumnya.
Release(Int32)	Keluar dari semaphore berapa kali yang ditentukan dan mengembalikan jumlah sebelumnya.
ToString()	Mengembalikan string yang mewakili objek saat ini. (Diperoleh dari Object)
TryOpenExisting(String, Semaphore)	Membuka semaphore bernama yang ditentukan, jika sudah ada, dan mengembalikan nilai yang menunjukkan apakah operasi berhasil.
WaitOne()	Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal. (Diperoleh dari WaitHandle)
WaitOne(Int32)	Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal, menggunakan bilangan bulat bertanda tangan 32-bit untuk menentukan interval waktu dalam milidetik. (Diperoleh dari WaitHandle)
WaitOne(Int32, Boolean)	Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal, menggunakan bilangan bulat bertanda tangan 32-bit untuk menentukan interval waktu dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu. (Diperoleh dari WaitHandle)
WaitOne(TimeSpan)	Memblokir utas saat ini hingga instans saat ini menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu. (Diperoleh dari WaitHandle)
WaitOne(TimeSpan, Boolean)	Memblokir utas saat ini hingga instans saat ini menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu. (Diperoleh dari WaitHandle)

Metode Ekstensi

GetAccessControl(Semaphore)	Mengembalikan deskriptor keamanan untuk yang ditentukan semaphore.
SetAccessControl(Semaphore, SemaphoreSecurity)	Mengatur deskriptor keamanan untuk semaphore yang ditentukan.
GetSafeWaitHandle(WaitHandle)	Mendapatkan handel yang aman untuk handel tunggu sistem operasi asli.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Mengatur handel yang aman untuk handel tunggu sistem operasi asli.

Keamanan Thread

Jenis ini aman untuk utas.

Lihat juga

• Pengaluran Terkelola
• Semaphore