Semaphore Kelas

Definisi

Ruang nama:

System.Threading

Rakitan:

netstandard.dll, 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 overload 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 metode kelebihan beban untuk merilis Release() 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;
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 diwariskan dari WaitHandle kelas , dan melepaskan semaphore dengan memanggil Release metode .

Hitungan pada semaphore ditentukan setiap kali utas memasuki semaphore, dan bertambah ketika utas melepaskan semaphore. Ketika jumlahnya nol, permintaan berikutnya memblokir hingga utas lain merilis semaphore. Ketika semua utas telah merilis semaphore, jumlahnya 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. Ini adalah tanggung jawab programmer untuk memastikan bahwa utas tidak melepaskan semaphore terlalu banyak kali. Misalnya, anggaplah semaphore memiliki batas maksimum dua, dan baik utas A maupun utas B memasuki semaphore tersebut. Jika kesalahan pemrograman di utas B menyebabkannya memanggil Release dua kali, kedua panggilan berhasil. Hitungan pada semaphore penuh, dan ketika utas A akhirnya memanggil Release, sebuah SemaphoreFullException dilemparkan.

Semaphores terdiri dari dua jenis: semaphores lokal dan bernama semaphores sistem. Jika Anda membuat Semaphore objek menggunakan konstruktor yang menerima nama, objek tersebut dikaitkan dengan semaphore sistem operasi dari nama tersebut. Semaphores 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. Ini dapat digunakan oleh utas apa pun dalam proses Anda yang memiliki referensi ke objek lokal Semaphore . 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 overload 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

Nama	Deskripsi
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.
Semaphore(Int32, Int32, String, NamedWaitHandleOptions, Boolean)	Menginisialisasi instans Semaphore baru kelas, menentukan jumlah awal entri dan jumlah maksimum entri bersamaan, secara opsional menentukan nama objek dan opsi semaphore sistem untuk mengatur akses cakupan pengguna dan cakupan sesi, dan menentukan variabel yang menerima nilai yang menunjukkan apakah semaphore sistem baru dibuat.
Semaphore(Int32, Int32, String, NamedWaitHandleOptions)	Menginisialisasi instans Semaphore baru kelas, menentukan jumlah awal entri dan jumlah maksimum entri bersamaan, dan secara opsional menentukan nama objek dan opsi semaphore sistem untuk mengatur akses cakupan pengguna dan cakupan sesi.
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)	Menginisialisasi instans Semaphore baru kelas, menentukan jumlah awal entri dan jumlah maksimum entri bersamaan.

Bidang

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

Properti

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

Metode

Nama	Deskripsi
Close()	Merilis semua sumber daya yang dipegang oleh saat ini WaitHandle. (Diperoleh dari WaitHandle)
Dispose()	Merilis semua sumber daya yang digunakan oleh instans WaitHandle kelas saat ini. (Diperoleh dari WaitHandle)
Dispose(Boolean)	Saat ditimpa di kelas turunan, merilis sumber daya yang tidak dikelola 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 Type instans 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 Objectsaat ini. (Diperoleh dari Object)
MemberwiseClone(Boolean)	Membuat salinan dangkal objek MarshalByRefObject saat ini. (Diperoleh dari MarshalByRefObject)
OpenExisting(String, NamedWaitHandleOptions)	Membuka semaphore bernama yang ditentukan, jika sudah ada. Jika opsi diatur ke pengguna saat ini saja, kontrol akses objek diverifikasi untuk pengguna panggilan.
OpenExisting(String)	Membuka semaphore bernama yang ditentukan, jika sudah ada.
Release()	Keluar dari semaphore dan mengembalikan jumlah sebelumnya.
Release(Int32)	Keluar dari semaphore berapa kali dan mengembalikan jumlah sebelumnya.
ToString()	Mengembalikan string yang mewakili objek saat ini. (Diperoleh dari Object)
TryOpenExisting(String, NamedWaitHandleOptions, Semaphore)	Membuka semaphore bernama yang ditentukan, jika sudah ada, dan mengembalikan nilai yang menunjukkan apakah operasi berhasil. Jika opsi diatur ke pengguna saat ini saja, kontrol akses objek diverifikasi untuk pengguna panggilan.
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, 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(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(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)
WaitOne(TimeSpan)	Memblokir utas saat ini hingga instans saat ini menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu. (Diperoleh dari WaitHandle)

Metode Ekstensi

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

Keamanan Thread

Jenis ini aman untuk utas.

Lihat juga

• Managed Threading
• Semaphore