Κοινή χρήση τεχνολογίας

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

---

Στον ταυτόχρονο προγραμματισμό, ο συγχρονισμός είναι βασική απαίτηση. Το Semaphore είναι ένας κοινός μηχανισμός συγχρονισμού που χρησιμοποιείται για τον έλεγχο της πρόσβασης σε κοινόχρηστους πόρους. Στην C#, οι σηματοφόροι υλοποιούνται μέσω της κλάσης Semaphore κάτω από τον χώρο ονομάτων System.Threading. Αυτό το άρθρο θα παρουσιάσει λεπτομερώς το Semaphore και τις εφαρμογές του σε C#.

1. Τι είναι σηματοφόρος;

Ο σηματοφόρος είναι μια ακέραια τιμή που μπορεί να χρησιμοποιηθεί για τον έλεγχο της πρόσβασης σε έναν κοινόχρηστο πόρο. Οι σηματοφόροι χρησιμοποιούνται κυρίως για δύο σκοπούς:

Αμοιβαία αποκλειστικές: Βεβαιωθείτε ότι μόνο ένα νήμα μπορεί να έχει πρόσβαση σε κοινόχρηστους πόρους ταυτόχρονα.
μετρώ: Επιτρέψτε σε έναν ορισμένο αριθμό νημάτων να έχουν πρόσβαση σε κοινόχρηστους πόρους ταυτόχρονα.
Οι σηματοφόροι χρησιμοποιούνται συνήθως στα ακόλουθα σενάρια:

• Περιορίστε την ταυτόχρονη πρόσβαση σε πόρους, όπως ο περιορισμός του αριθμού των συνδέσεων βάσης δεδομένων.
• Συγχρονισμός ανάγνωσης και εγγραφής δεδομένων σε πρόβλημα παραγωγού-καταναλωτή.
• Συγχρονίστε την πρόσβαση σε κοινόχρηστους πόρους μεταξύ πολλαπλών διεργασιών.

2. Κατηγορία σηματοφόρου σε C#

Στην C#, η κλάση Semaphore παρέχει βασικές λειτουργίες σε σηματοφόρους. Για να δημιουργήσετε έναν σηματοφόρο, χρησιμοποιήστε την ακόλουθη σύνταξη:

Semaphore semaphore = new Semaphore(initialCount, maximumCount);
1

initialCount: Η αρχική τιμή μέτρησης του σηματοφόρου, που υποδεικνύει την τιμή του σηματοφόρου όταν δημιουργήθηκε.
MaximumCount: Η μέγιστη τιμή καταμέτρησης του σηματοφόρου, που υποδεικνύει τη μέγιστη τιμή που μπορεί να φτάσει ο σηματοφόρος.

3. Παραδείγματα χρήσης σηματοφόρων

3.1 Δημιουργήστε έναν σηματοφόρο

Στη C#, δημιουργήστε έναν σηματοφόρο χρησιμοποιώντας την κλάση SemaphoreSlim. Αυτή η κλάση είναι μια υλοποίηση περιβάλλοντος συγχρονισμού του Semaphore, παρέχοντας πιο ευέλικτες ασύγχρονες λειτουργίες.

χρησιμοποιώντας System.Threading;

δημόσια τάξη SemaphoreExample
{
private SemaphoreSlim semaphore = new SemaphoreSlim(3).

public void DoWork()
{
    semaphore.Wait(); // 获取信号量，如果信号量小于0，线程将被阻塞

    try
    {
        // 执行共享资源的操作
    }
    finally
    {
        semaphore.Release(); // 释放信号量
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

}

3.2 Χρησιμοποιήστε σηματοφόρους για να συγχρονίσετε νήματα

Το παρακάτω είναι ένα απλό παράδειγμα για να δείξετε πώς μπορείτε να δημιουργήσετε, να αποκτήσετε και να απελευθερώσετε πόρους σηματοφόρου.

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 创建信号量，允许3个线程同时访问共享资源
        Semaphore semaphore = new Semaphore(3, 3);

        // 创建和启动线程
        for (int i = 0; i < 10; i++)
        {
            new Thread(() => Work(semaphore)).Start();
        }
    }

    static void Work(Semaphore semaphore)
    {
        try
        {
            // 获取信号量
            semaphore.WaitOne();

            // 执行共享资源的操作
            Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 正在执行。");
            Thread.Sleep(1000);
        }
        finally
        {
            // 释放信号量
            semaphore.Release();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

Σε αυτό το παράδειγμα, δημιουργούμε έναν σηματοφόρο που επιτρέπει έως και 3 νήματα να εκτελέσουν τη μέθοδο Work ταυτόχρονα. Κάθε νήμα επιχειρεί να αποκτήσει τον σηματοφόρο κατά την κλήση του semaphore.WaitOne(). Εάν η τιμή του σηματοφόρου είναι μεγαλύτερη από 0, το νήμα θα συνεχίσει να εκτελείται. Διαφορετικά, το νήμα θα αποκλειστεί έως ότου ένα άλλο νήμα απελευθερώσει τον σηματοφόρο.

Ασύγχρονες λειτουργίες
Η κλάση SemaphoreSlim παρέχει επίσης μεθόδους ασύγχρονης αναμονής και απελευθέρωσης:

1. await semaphore.WaitAsync(): Ασύγχρονη αναμονή για το σηματοφόρο
2. await semaphore.ReleaseAsync(): Απελευθερώστε τον σηματοφόρο ασύγχρονα

Αυτό κάνει τη χρήση των σηματοφόρους πιο ευέλικτη και καλύτερα ενσωματωμένη με μοντέλα ασύγχρονου προγραμματισμού.

4. Περίληψη

Το Semaphore (semaphore) σε C# είναι ένας ισχυρός μηχανισμός συγχρονισμού που μπορεί να βοηθήσει τους προγραμματιστές να ελέγξουν την πρόσβαση σε κοινόχρηστους πόρους. Χρησιμοποιώντας σηματοφόρους, μπορούμε να διαχειριστούμε αποτελεσματικά την πρόσβαση πολλών νημάτων σε κοινόχρηστους πόρους, διασφαλίζοντας ότι η χρήση των πόρων δεν προκαλεί αγώνες δεδομένων ή άλλα προβλήματα συγχρονισμού.

Η σημασία του Semaphore στον προγραμματισμό C# αντανακλάται στην ικανότητά του να βοηθά τους προγραμματιστές να εφαρμόσουν σύνθετη λογική ελέγχου ταυτόχρονης χρήσης, διατηρώντας παράλληλα την αναγνωσιμότητα και τη συντηρησιμότητα του κώδικα. Η ευκολία χρήσης του αντικατοπτρίζεται στον απλό σχεδιασμό API και την πλούσια υποστήριξη συγχρονισμού.

Σε πρακτικές εφαρμογές, οι σηματοφόροι μπορούν να χρησιμοποιηθούν για τον περιορισμό του μεγέθους της δεξαμενής σύνδεσης της βάσης δεδομένων, τον έλεγχο της πρόσβασης σε πόρους δικτύου και την επίτευξη συγχρονισμού του μοντέλου παραγωγού-καταναλωτή κ.λπ. Μέσα από την εισαγωγή αυτού του άρθρου, ελπίζουμε ότι οι αναγνώστες μπορούν να κατανοήσουν καλύτερα τις αρχές και τη χρήση του Semaphore και να το εκμεταλλευτούν σε πραγματικά έργα.