Comment implémenter des modèles de mutex globaux robustes en C #?

C # La réalisation fiable du mode corps mutuel global

La classe Mutex dans C # fournit un mécanisme pour contrôler l'accès à plusieurs threads ou processus de partage de ressources. Le corps mutuel mondial a une portée systématique et a proposé des défis uniques pour assurer une utilisation sûre et fiable. Cet article traite d'un modèle complet de création et d'utilisation efficace des spécaires mutuels globaux et résout les aspects clés de l'indépendance régionale, la libération de licenciement mutuel correct et le traitement des conditions anormales.

Implémentation du mode MODE

L'exemple de code suivant montre le mode fiable d'utilisation du corps mutuel global:

Caractéristiques de clés

<code class="language-csharp">using System.Runtime.InteropServices;   //GuidAttribute
using System.Reflection;                //Assembly
using System.Threading;                 //Mutex
using System.Security.AccessControl;    //MutexAccessRule
using System.Security.Principal;        //SecurityIdentifier

// ...

// 主应用程序逻辑
static void Main(string[] args)
{
    // 获取应用程序的唯一GUID
    string appGuid =
        ((GuidAttribute)Assembly.GetExecutingAssembly()
            .GetCustomAttributes(typeof(GuidAttribute), false)
                .GetValue(0)).Value.ToString();

    // 创建全局唯一的互斥体ID
    string mutexId = string.Format( "Global\{{{0}}}", appGuid );

    // 为多用户使用建立安全设置
    var allowEveryoneRule =
        new MutexAccessRule( new SecurityIdentifier( WellKnownSidType.WorldSid
                                                   , null)
                           , MutexRights.FullControl
                           , AccessControlType.Allow
                           );
    var securitySettings = new MutexSecurity();
    securitySettings.AddAccessRule(allowEveryoneRule);

    // 使用指定的ID和安全设置初始化互斥体
    using (var mutex = new Mutex(false, mutexId, out bool createdNew, securitySettings))
    {
        // 尝试获取互斥体句柄，设置超时
        var hasMutexHandle = false;
        try
        {
            hasMutexHandle = mutex.WaitOne(5000, false);
        }
        catch (AbandonedMutexException)
        {
            // 记录日志并获取被放弃的互斥体
            hasMutexHandle = true;
        }

        // 在互斥体范围内执行关键操作
        if (hasMutexHandle)
        {
            // ...
            mutex.ReleaseMutex();
        }
    }
}</code>

Indépendance des paramètres régionaux: L'ID mutualisé utilise la génération de GUID de l'application pour s'assurer qu'elle est unique dans différents domaines.

Assurez-vous que la dispersion mutuelle est libérée:
• L'utilisation du bloc libère automatiquement le corps mutuellement exclusif lorsqu'il dépasse la plage, éliminant le risque de corps mutuel en suspension. OUT TRAITEMENT DU TEMPS:
Spécifiez les heures supplémentaires facultatives lors de l'obtention du corps mutuellement exclusif pour empêcher une attente illimitée.
• Le traitement mutuellement exclusif abandonné: élégant pour obtenir l'organisme mutuel abandonné pour s'assurer que l'exécution du programme ne sera pas bloquée indéfiniment.
• Sécurité multi-utilisateurs: Exclusion mutuelle pour accorder des autorisations d'accès explicites à tous les utilisateurs, permettant la collaboration et le partage des ressources.
• Conclusion
Ce modèle fournit une base solide pour l'utilisation du corps mutuel global en C # pour assurer une exécution sûre et fiable. En suivant ces critères, les développeurs peuvent gérer efficacement le partage des ressources et prévenir les problèmes potentiels liés à l'utilisation d'alternatives mutuelles.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!