C#线程学习笔记六：线程同步--信号量和互斥体

时间 2019-12-16

标签 c# 线程学习笔记同步信号互斥栏目 C# 繁體版

原文原文链接

本笔记摘抄自：https://www.cnblogs.com/zhili/archive/2012/07/23/Mutex_And_Semaphore.html，记录一下学习过程以备后续查用。html

1、信号量（Semaphore）函数

信号量（Semaphore）是由内核对象维护的int变量。当信号量为0时，在信号量上等待的线程会堵塞；信号量大于0时，就解除堵塞。当在一个信号量上等待学习

的线程解除堵塞时，内核自动会将信号量的计数减1。在.NET下经过Semaphore类来实现信号量同步。ui

Semaphore类限制可同时访问某一资源或资源池的线程数。线程经过调用 WaitOne方法将信号量减1，并经过调用Release方法把信号量加1。spa

先说下构造函数：线程

public Semaphore(int initialCount,int maximumCount);经过两个参数来设置信号的初始计数和最大计数。3d

下面代码演示信号量同步的使用：code

    class Program
    {
        //共享资源
        public static int number = 0;
        //初始信号量计数为0，最大计数为10。
        public static Semaphore semaphore = new Semaphore(0, 10);

        static void Main(string[] args)
        {
            #region 线程同步：使用信号量实现同步
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(new ParameterizedThreadStart(SemaphoreMethod));
                thread.Start(i);
            }

            //每次增长2个信号量，即每次释放2个线程。
            for (int j = 0; j < 5; j++)
            {
                Console.WriteLine("红灯转绿灯……");
                semaphore.Release(2);
                Thread.Sleep(1000);
            }
            Console.Read();
            #endregion
        }

        /// <summary>
        /// Semaphore方法
        /// </summary>
        public static void SemaphoreMethod(object parameter)
        {
            while ((int)parameter != number)
            {
                Thread.Sleep(100);
            }
            //信号量计数减1
            semaphore.WaitOne();
            Console.WriteLine("The current value of number is:{0}", ++number);
        }
    }

运行结果以下：htm

与上一篇AutoResetEvent相似，信号量也能够实现跨进程间的线程同步。经过调用public Semaphore(int initialCount,int maximumCount,string name);构造函数，对象

传入一个信号量名来实现此功能。

下面代码演示跨进程间的线程同步：

第一个进程代码：

    class Program
    {
        //共享资源
        public static int number = 0;
              
        //初始信号量计数为0，最大计数为10。
        public static Semaphore semaphore1 = new Semaphore(0, 10, "Semaphore1");
        public static Semaphore semaphore2 = new Semaphore(0, 10, "Semaphore2");

        static void Main(string[] args)
        {
            #region 线程同步：使用信号量实现跨进程之间的线程同步
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(new ParameterizedThreadStart(Semaphore1Method));
                thread.Start(i);
            }

            //为了有时间去启动另一个进程
            Thread.Sleep(15000);

            //每次增长2个信号量，即每次释放2个线程。
            for (int j = 0; j < 5; j++)
            {
                Console.WriteLine("信号灯1红灯转绿灯……");
                semaphore1.Release(2);
                Console.WriteLine("信号灯2红灯转绿灯……");
                semaphore2.Release(2);
                Thread.Sleep(1000);
            }
            Console.Read();
            #endregion
        }

        /// <summary>
        /// Semaphore1方法
        /// </summary>
        public static void Semaphore1Method(object parameter)
        {
            while ((int)parameter != number)
            {
                Thread.Sleep(100);
            }
            //信号量计数减1
            semaphore1.WaitOne();
            Console.WriteLine("Semaphore1:The current value of number is:{0}", ++number);
        }
    }

第二个进程代码：

    class Program
    {
        //共享资源
        public static int number = 0;
        //建立对象
        public static Semaphore semaphore2 = new Semaphore(0, 10, "Semaphore2");

        static void Main(string[] args)
        {
            #region 经过信号量实现跨进程间的线程同步
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(new ParameterizedThreadStart(Semaphore2Method));
                thread.Start(i);
            }
            Console.Read();
            #endregion
        }

        /// <summary>
        /// Semaphore2方法
        /// </summary>
        public static void Semaphore2Method(object parameter)
        {
            while ((int)parameter != number)
            {
                Thread.Sleep(100);
            }
            //信号量计数减1
            semaphore2.WaitOne();
            Console.WriteLine("Semaphore2:The current value of number is:{0}", ++number);
        }
    }

运行结果以下：

从结果能够看出，第一个进程的semaphore2.Release(2);信号发出后，第二个进程能够收到并释放线程。

2、互斥体（Mutex）

Mutex对象是一个同步基元，当某一个线程占用Mutex对象时，其余也须要占用Mutex的线程将处于挂起状态。

下面代码演示互斥体同步的使用：

    class Program
    {
        //共享资源
        public static int number = 0;
        //互斥体
        public static Mutex mutex = new Mutex();
        
        static void Main(string[] args)
        {
             #region 线程同步：使用互斥体实现同步
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(MutexMethod);
                thread.Start();
            }

            Console.Read();
            #endregion
        }

        /// <summary>
        /// Mutex方法
        /// </summary>
        public static void MutexMethod(object parameter)
        {
            mutex.WaitOne();
            Thread.Sleep(500);
            Console.WriteLine("The current value of number is:{0}", ++number);
            mutex.ReleaseMutex();
        }
    }

运行结果以下：

下面代码演示跨进程间的线程同步：

第一个进程代码：

    class Program
    {
        //共享资源
        public static int number = 0;
  
        //互斥体
        public static Mutex mutex1 = new Mutex(false, "Mutex1");
        public static Mutex mutex2 = new Mutex(false, "Mutex2");

        static void Main(string[] args)
        {
            #region 线程同步：使用互斥体实现跨进程之间的线程同步
            mutex1.WaitOne();
            mutex2.WaitOne();
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(new ParameterizedThreadStart(Mutex1Method));
                thread.Start(i);
            }

            //为了有时间去启动另一个进程
            Thread.Sleep(15000);
            mutex1.ReleaseMutex();
            mutex2.ReleaseMutex();
            Console.Read();
            #endregion
        }

        /// <summary>
        /// Mutex1方法
        /// </summary>
        public static void Mutex1Method(object parameter)
        {
            mutex1.WaitOne();
            Thread.Sleep(500);
            Console.WriteLine("Mutex1:The current value of number is:{0}", ++number);
            mutex1.ReleaseMutex();
        }
    }

第二个进程代码：

    class Program
    {
        //共享资源
        public static int number = 0;
        //建立对象
        public static Mutex mutex2 = new Mutex(false, "Mutex2");

        static void Main(string[] args)
        {
            #region 经过互斥体实现跨进程之间的线程同步
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(new ParameterizedThreadStart(Mutex2Method));
                thread.Start(i);
            }
            Console.Read();
            #endregion
        }

        /// <summary>
        /// Mutex2方法
        /// </summary>
        public static void Mutex2Method(object parameter)
        {
            mutex2.WaitOne();
            Thread.Sleep(500);
            Console.WriteLine("Mutex2:The current value of number is:{0}", ++number);
            mutex2.ReleaseMutex();
        }
    }

运行结果以下：

从结果能够看出，第一个进程的mutex2.ReleaseMutex();信号发出后，第二个进程能够收到并释放线程。