5天不再惧怕多线程——第四天 信号量

转载 2012年03月21日 14:18:16
 今天整理“信号量”的相关知识,其实想想也蛮有趣的,锁,互斥,信号量都可以实现线程同步,在framework里面主要有三种。

<1>:ManualResetEvent

<2>:AutoResetEvent

<3>: Semaphore

 

好,下面就具体看看这些玩意的使用。

 

一:ManualResetEvent

      该对象有两种信号量状态True和False,好奇的我们肯定想知道True和False有什么区别,稍后的例子见分晓,有三个方法值得学习一下。

1:WaitOne

     该方法用于阻塞线程,默认是无限期的阻塞,有时我们并不想这样,而是采取超时阻塞的方法,如果超时就放弃阻塞,这样也就避免了无限期

       等待的尴尬。

2:Set

     手动修改信号量为True,也就是恢复线程执行。

3:ReSet

     手动修改信号量为False,暂停线程执行。

 

好了,下面举个例子说明一下。

 

<1>  信号量初始为False,WaitOne采用无限期阻塞,可以发现线程间可以进行交互。

 1 public class Example
 
2 {
 3     public static void Main()
 4     {
 5         Thread t = new Thread(Run);
 6 
 
 7         t.Name = "Jack";
 8 
 9         Console.WriteLine("当前时间:{0}  {1} {1},我是主线程,收到请回答。", DateTime.Now, t.Name);
10 
11         t.Start();
12 
13         Thread.Sleep(5000);
14 
15         mr.Set();
16 
17         Console.Read();
18     }
19 
20     static ManualResetEvent mr = new ManualResetEvent(false);
21 
22     static void Run()
23     {
24         mr.WaitOne();
25 
26         Console.WriteLine("\n当前时间:{0}  主线程,主线程,{1}已收到!", DateTime.Now, Thread.CurrentThread.Name);
27     }
28 

 

 

<2> 信号量初始为True,WaitOne采用无限期阻塞,实验发现WaitOne其实并没有被阻塞。

 static ManualResetEvent mr = new ManualResetEvent(true);

 

<3>信号量初始为False,WaitOne采用超时2s,虽然主线程要等5s才能进行Set操作,但是WaitOne已经等不及提前执行了。

 1 public class Example
 2 {
 3     public static void Main()
 4     {
 5         Thread t = new Thread(Run);
 6 
 7         t.Name = "Jack";
 8 
 9         Console.WriteLine("当前时间:{0}  {1} {1},我是主线程,收到请回答。", DateTime.Now, t.Name);
10 
11         t.Start();
12 
13         Thread.Sleep(5000);
14 
15         mr.Set();
 
16 
17         Console.Read();
18     }
19 
20     static ManualResetEvent mr = new ManualResetEvent(false);
21 
22     static void Run()
23     {
24         mr.WaitOne(2000);
25 
26         Console.WriteLine("\n当前时间:{0}  主线程,主线程,{1}已收到!", DateTime.Now, Thread.CurrentThread.Name);
27     }
28 }

 


二:AutoResetEvent

      在VS对象浏览器中,我们发现AutoResetEvent和ManualResetEvent都是继承于EventWaitHandle,所以基本功能是一样的,不过值得注意

的一个区别是WaitOne会改变信号量的值,比如说初始信号量为True,如果WaitOne超时信号量将自动变为False,而ManualResetEvent则不会。

 1 public class Example
 
2 {
 3     public static void Main()
 4     {
 5         Thread t = new Thread(Run);
 6 
 7         t.Name = "Jack";
 
 8 
 9         t.Start();
10 
11         Console.Read();
12     }
13 
 
14     static AutoResetEvent ar = new AutoResetEvent(true);
15 
16     static void Run()
17     {
18         var state = ar.WaitOne(1000, true);
 
19 
20         Console.WriteLine("我当前的信号量状态:{0}", state);
21 
22         state = ar.WaitOne(1000, true);
23 
24         Console.WriteLine("我恨你,不理我,您现在的状态是:{0}", state);
25 
26     }
27 }
 

 

 

三:Semaphore 

     这玩意是.net 4.0新增的,用于控制线程的访问数量,默认的构造函数为initialCount和maximumCount,表示默认设置的信号量个数和

最大信号量个数,其实说到底,里面是采用计数器来来分配信号量,当你WaitOne的时候,信号量自减,当Release的时候,信号量自增,然而

当信号量为0的时候,后续的线程就不能拿到WaitOne了,所以必须等待先前的线程通过Release来释放。

 

好了,下面还是举例子来说明一下:

 

<1> initialCount=1,maximunCount=10,WaitOne采用无限期等待。

 1 namespace ConsoleApplication3
 
2 {
 3     class Program
 4     {
 5         static void Main(string[] args)
 
 6         {
 7 
 8             Thread t1 = new Thread(Run1);
 9             t1.Start();
10 
11             Thread t2 = new Thread(Run2);
12             t2.Start();
13 
14             Console.Read();
15         }
16 
17         static Semaphore sem = new Semaphore(1, 10);
18 
19         static void Run1()
20         {
21             sem.WaitOne();
22 
23             Console.WriteLine("大家好,我是Run1");
24         }
25 
26         static void Run2()
27         {
28             sem.WaitOne();
29 
30             Console.WriteLine("大家好,我是Run2");
31         }
32     }
33 }
 

我们悲剧的发现t2线程不能执行,我们知道WaitOne相当于自减信号量,然而默认的信号量个数为1,所以t2想执行必须等待t1通过Release来释放。

1         static void Run1()
2         {
3             sem.WaitOne();
4 
5             Console.WriteLine("大家好,我是Run1");
6 
7             sem.Release();
8         }
 
 

可能有的同学要问,我不是设置了maximunCount=10吗?为什么没有起到作用?是的,默认情况下是没有起到作用,必须要我们手动干预一下,

我们知道调用Release方法相当于自增一个信号量,然而Release有一个重载,可以指定自增到maximunCount个信号量,这里我就在主线程上

Release(10),看看效果。

 1 namespace ConsoleApplication3
 2 {
 3     class Program
 4     {
 
 5         static void Main(string[] args)
 6         {
 7 
 8             Thread t1 = new Thread(Run1);
 9             t1.Start();
10 
11             Thread t2 = new Thread(Run2);
12             t2.Start();
13 
14             Thread.Sleep(1000);
15 
16             sem.Release(10);
17 
18             Console.Read();
19         }
20 
21         static Semaphore sem = new Semaphore(1, 10); 
 
23         static void Run1()
24         {
25             sem.WaitOne();
26 
27             Console.WriteLine("大家好,我是Run1");
28         }
29 
30         static void Run2()
31         {
32             sem.WaitOne();
33 
34             Console.WriteLine("大家好,我是Run2");
35         }
36     }
37 }
 


<2> Semaphore命名,升级进程交互。

      在VS对象浏览器中发现Semaphore是继承字WaitHandle,而WaitHandle封装了win32的一些同步机制,所以当我们给Semaphore命名的时候

就会在系统中可见,下面举个例子,把下面的代码copy一份,运行两个程序。

 1 namespace ConsoleApplication3
 2 {
 3     class Program
 4     {
 5         static void Main(string[] args)
 6         {
 
 7 
 8             Thread t1 = new Thread(Run1);
 9             t1.Start();
10 
11             Thread t2 = new Thread(Run2);
12             t2.Start();
13 
14             Console.Read();
15         }
16 
17         static Semaphore sem = new Semaphore(3, 10, "cnblogs");
18 
19         static void Run1()
20         {
21             sem.WaitOne();
22 
23             Console.WriteLine("当前时间:{0} 大家好,我是Run1", DateTime.Now);
24         }
25 
26         static void Run2()
27         {
28             sem.WaitOne();
29 
30             Console.WriteLine("当前时间:{0} 大家好,我是Run2", DateTime.Now);
31         }
32     }
33 }

 

 

 

是的,我设置了信号量是3个,所以只能有三个线程持有WaitOne,后续的线程只能苦苦的等待。

相关文章推荐

5天不再惧怕多线程——第一天 尝试Thread

原本准备在mongodb之后写一个lucene.net系列,不过这几天用到多线程时才发现自己对多线程的了解少之又少,仅仅停留在lock上面, 故这几天看了下线程参考手册结合自己的心得整理一下放在博客...

5天不再惧怕多线程——第一天 尝试Thread

原本准备在mongodb之后写一个lucene.net系列,不过这几天用到多线程时才发现自己对多线程的了解少之又少,仅仅停留在lock上面, 故这几天看了下线程参考手册结合自己的心得整理一下放在博客...

5天不再惧怕多线程——第一天 尝试Thread

作者: 转自:
  • whw8007
  • whw8007
  • 2014年10月28日 11:11
  • 1761

5天不再惧怕多线程——第二天 锁机制

当多个线程在并发的时候,难免会碰到相互冲突的事情,比如最经典的ATM机的问题,并发不可怕,可怕的是我们没有能力控制。 线程以我的理解可以分为三种 ① 锁。 ② 互斥。 ③ 信号。   好,这...

GCD实践——多线程图片下载与信号量开发实践

在实际的项目开发中,我们往往需要从网络加载图片资源,为了不影响主线程,我们需要开辟新的线程。同时为了控制不同线程之间的前后顺序,需要引入信号量机制。这里我们来实现一个案例:从网络加载3张图片,当加载完...

linux多线程学习(六)——信号量实现同步

在上一篇文章中已经用信号量来实现线程间的互斥,达到了互斥锁的效果,今天这篇文章将讲述怎样用信号量去实现同步。 信号量的互斥同步都是通过PV原语来操作的,我们可以通过注册两个信号量,让它们在互斥的问题...

多线程通信——信号量

当当前资源的数量大于0的时候,等待信号量的线程可以获得一个资源并继续执行,信号量的当前资源数量将减1,如果当前资源的数量为0,则等待信号量的线程将处于等待状态,直到有线程释放信号量,使信号量标识的资源...

linux多线程学习(六)——信号量实现同步

 在上一篇文章中已经用信号量来实现线程间的互斥,达到了互斥锁的效果,今天这篇文章将讲述怎样用信号量去实现同步。 信号量的互斥同步都是通过PV原语来操作的,我们可以通过注册两个信号量,让它们...
  • BBZZ2
  • BBZZ2
  • 2016年02月01日 17:42
  • 255

iOS多线程开发—— GCD dispatch_semaphore 信号量

在GCD中提供了一种信号机制,也可以解决资源抢占问题(和同步锁的机制并不一样)。 GCD中信号量是dispatch_semaphore_t类型,支持信号通知和信号等待。每当发送一个信号通知,则信号量 ...
  • xiao__L
  • xiao__L
  • 2016年11月01日 10:37
  • 220

linux多线程学习(五)——信号量线程控制

在上一篇文章中,讲述了线程中互斥锁的使用,达到对共享资源互斥使用。除了使用互斥锁,信号量,也就是操作系统中所提到的PV原语,能达到互斥和同步的效果,这就是今天我们所要讲述的信号量线程控制。 PV原语...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:5天不再惧怕多线程——第四天 信号量
举报原因:
原因补充:

(最多只允许输入30个字)