线程同步编程,线程也疯狂

By admin in 编程 on 2019年5月7日

根本形式结构

前篇我们已经提过,内核形式组织比用户情势结构慢繁多,三个缘由是它们要求Windows操作系统本人的合作,另一个缘故是基本对象上调用的种种方法都导致调用线程从托管代码转变为本机用户方式代码,再转移为背景内核情势代码,这一个调换要求多量的CPU时间。

而是根本格局抱有用户形式尚未的帮助和益处:

  1. 当检查实验到能源竞争时,windows会阻塞输掉的线程

  2. 可一齐一台机械中分裂进度中运营的线程

  3. 卫戍未经授权的账户访问线程

  4. 闭塞的线程能够钦点超时值

事件和时限信号量即是三种基本格局线程同步构造。

WaitHandle抽象基类,唯一的作用便是包裹四个windows内核对象句柄,承接WaitHadle的对象足以分为3类:壹.
事件协会(AutoReset伊夫nt、马努alReset伊芙nt) 二. Semaphore构造 三.
Mutex构造

线程也疯狂—–线程同步(2),—–线程同步

事件组织

AutoReset伊芙nt、马努alReset伊夫nt:其核心职业原理是多少个线程持有同3个XXXReset伊夫nt,在这些XXXReset伊夫nt未被set前,各线程都在WaitOne()除挂起;在那个XXXReset伊芙nt被set后,全部被挂起的线程中有多少个(AutoReset伊夫nt的情事下)或任何(马努alReset伊夫nt的事态下)苏醒实施。

 

AutoResetEvent举例:

 1  AutoResetEvent autoResetEvent = new AutoResetEvent(true); //true默认执行第一个未挂起的线程
 2 
 3             Task.Factory.StartNew(() =>
 4             {
 5                 Console.WriteLine("线程1:我已经开始任务已经执行,等待指示");
 6                 autoResetEvent.WaitOne();
 7                 Console.WriteLine("线程1任务执行结束");
 8                 autoResetEvent.Set();
 9             });
10 
11 
12             Task.Factory.StartNew(() =>
13             {
14                 Console.WriteLine("线程2:我已经开始任务已经执行,等待指示");
15                // Thread.Sleep(1000);
16                 autoResetEvent.WaitOne();
17                 Console.WriteLine("线程2任务执行结束");;
18             });
19             Console.WriteLine("程序结束");
20             Console.ReadLine();

 

ManualResetEvent举例:

 1  ManualResetEvent autoResetEvent = new ManualResetEvent(false); //true默认执行第一个未挂起的线程
 2 
 3             Task.Factory.StartNew(() =>
 4             {
 5                 Console.WriteLine("线程1:我已经开始任务已经执行,等待指示");
 6                 autoResetEvent.WaitOne();
 7                 Console.WriteLine("线程1任务执行结束");
 8 
 9             });
10             Task.Factory.StartNew(() =>
11             {
12                 Console.WriteLine("线程2:我已经开始任务已经执行,等待指示");
13                // Thread.Sleep(1000);
14                 autoResetEvent.WaitOne();
15                 Console.WriteLine("线程2任务执行结束");;
16             });
17             Console.WriteLine("1s后再通知线程执行任务");
18             Thread.Sleep(1000);
19             autoResetEvent.Set();
20             Console.WriteLine("程序结束");
21             Console.ReadLine();

回忆有3个面试题,创造四个线程并且遵照顺序打字与印刷ABCD重复一回,就考得是线程同步的主题素材,大家能够思量一下怎么消除。

 

基础情势组织

前篇大家早就提过,内核方式结构比用户情势结构慢多数,五个缘故是它们供给Windows操作系统自己的配合,另三个缘由是基本对象上调用的种种方法都变成调用线程从托管代码调换为本机用户情势代码,再调换为背景内核形式代码,那几个调换必要大批量的CPU时间。

只是基础情势抱有用户格局尚未的帮助和益处:

  1. 当检验到财富竞争时,windows会阻塞输掉的线程

  2. 可同台壹台机械中差异进度中运营的线程

  3. 防护未经授权的账户访问线程

  4. 卡住的线程能够钦定超时值

事件和复信号量便是三种基础形式线程同步构造。

WaitHandle抽象基类,唯一的成效正是包装贰个windows内查对象句柄,承接WaitHadle的指标能够分成叁类:1.
事变组织(AutoReset伊夫nt、ManualReset伊夫nt) 二. 塞马phore构造 三.
Mutex社团

Semaphore构造

组织原理:通过基础维护int32变量,连续信号量为0时,在时域信号量上等候的线程会阻塞,信号量大于0时,解除阻塞,在时域信号量上等候的线程接触阻塞时,内核自动从复信号量的计数中减一.

 

 1   Semaphore semaphore = new Semaphore(0, Int32.MaxValue); //指定最大并发
 2 
 3             Task.Factory.StartNew(() =>
 4             {
 5                 Console.WriteLine("线程1:我已经开始任务已经执行,等待指示");
 6                 semaphore.WaitOne();
 7                 Console.WriteLine("线程1任务执行结束");
 8                 semaphore.Release();
 9 
10             });
11             Task.Factory.StartNew(() =>
12             {
13                 Console.WriteLine("线程2:我已经开始任务已经执行,等待指示");
14                // Thread.Sleep(1000);
15                 semaphore.WaitOne();
16                 Console.WriteLine("线程2任务执行结束");;
17             });
18             Console.WriteLine("1s后再通知线程执行任务");
19             semaphore.Release();
20             Console.WriteLine("程序结束");
21             Console.ReadLine();

 

事件协会

AutoReset伊芙nt、ManualReset伊芙nt:其基本职业规律是多个线程持有同叁个XXXResetEvent,在那个XXXReset伊芙nt未被set前,各线程都在WaitOne()除挂起;在这么些XXXReset伊夫nt被set后,全部被挂起的线程中有一个(AutoReset伊夫nt的图景下)或任何(马努alReset伊芙nt的情形下)恢复生机执行。

 

AutoResetEvent举例:

 1  AutoResetEvent autoResetEvent = new AutoResetEvent(true); //true默认执行第一个未挂起的线程
 2 
 3             Task.Factory.StartNew(() =>
 4             {
 5                 Console.WriteLine("线程1:我已经开始任务已经执行,等待指示");
 6                 autoResetEvent.WaitOne();
 7                 Console.WriteLine("线程1任务执行结束");
 8                 autoResetEvent.Set();
 9             });
10 
11 
12             Task.Factory.StartNew(() =>
13             {
14                 Console.WriteLine("线程2:我已经开始任务已经执行,等待指示");
15                // Thread.Sleep(1000);
16                 autoResetEvent.WaitOne();
17                 Console.WriteLine("线程2任务执行结束");;
18             });
19             Console.WriteLine("程序结束");
20             Console.ReadLine();

 

ManualResetEvent举例:

 1  ManualResetEvent autoResetEvent = new ManualResetEvent(false); //true默认执行第一个未挂起的线程
 2 
 3             Task.Factory.StartNew(() =>
 4             {
 5                 Console.WriteLine("线程1:我已经开始任务已经执行,等待指示");
 6                 autoResetEvent.WaitOne();
 7                 Console.WriteLine("线程1任务执行结束");
 8 
 9             });
10             Task.Factory.StartNew(() =>
11             {
12                 Console.WriteLine("线程2:我已经开始任务已经执行,等待指示");
13                // Thread.Sleep(1000);
14                 autoResetEvent.WaitOne();
15                 Console.WriteLine("线程2任务执行结束");;
16             });
17             Console.WriteLine("1s后再通知线程执行任务");
18             Thread.Sleep(1000);
19             autoResetEvent.Set();
20             Console.WriteLine("程序结束");
21             Console.ReadLine();

纪念有三个面试题,创设多少个线程并且根据顺序打字与印刷ABCD重复二次,就考得是线程同步的主题素材,大家能够思考一下怎么化解。

 

Mutex构造

规律同AtuoReset伊芙nt相似,都是1次只可以释放3个正值等待的线程,但是互斥有局地额外的逻辑,那使得它比在此之前的构造更盘根错节。首先,Mutex对象会询问调用线程的Int3二ID,记录是哪3个线程得到了它,多少个线程调用ReleaseMutex时,mutex确认保障调用线程就是获得Mutex的老大线程,不然mutex对象的场馆就能够发出改造,别的,Mutex对象保证着2个递归计数,提出全体该Mutex的线程具备了它多少次,假设3个线程当前具备二个mutex,而后该线程再度在mutex上等候,计数就能递增,那一个线程允许继续运维。

布局Mutex的递归锁:

 1 class MutexLock : IDisposable
 2     {
 3          private readonly Mutex mutex;
 4 
 5          public MutexLock()
 6         {
 7             mutex = new Mutex();
 8         }
 9 
10         public void Enter()
11         {
12             mutex.WaitOne();
13             //随便坐任何事情
14             Leave();
15             mutex.ReleaseMutex();
16 
17         }
18 
19         public void Leave()
20         {
21             mutex.WaitOne();
22             //随便坐任何事情
23             mutex.ReleaseMutex();
24         }
25 
26         public void Dispose()
27         {
28             mutex.Dispose();
29         }
30     }

 

Semaphore构造

布局原理:通过基础维护int32变量,时域信号量为0时,在能量信号量上等候的线程会阻塞,复信号量大于0时,解除阻塞,在随机信号量上等候的线程接触阻塞时,内核自动从实信号量的计数中减一.

 

 1   Semaphore semaphore = new Semaphore(0, Int32.MaxValue); //指定最大并发
 2 
 3             Task.Factory.StartNew(() =>
 4             {
 5                 Console.WriteLine("线程1:我已经开始任务已经执行,等待指示");
 6                 semaphore.WaitOne();
 7                 Console.WriteLine("线程1任务执行结束");
 8                 semaphore.Release();
 9 
10             });
11             Task.Factory.StartNew(() =>
12             {
13                 Console.WriteLine("线程2:我已经开始任务已经执行,等待指示");
14                // Thread.Sleep(1000);
15                 semaphore.WaitOne();
16                 Console.WriteLine("线程2任务执行结束");;
17             });
18             Console.WriteLine("1s后再通知线程执行任务");
19             semaphore.Release();
20             Console.WriteLine("程序结束");
21             Console.ReadLine();

 

Mutex构造

规律同AtuoReset伊芙nt相似,都是三遍只可以释放三个正值等待的线程,可是互斥有点外加的逻辑,这使得它比原先的构造更复杂。首先,Mutex对象会询问调用线程的Int3贰ID,记录是哪二个线程获得了它,三个线程调用ReleaseMutex时,mutex确认保证调用线程就是赢得Mutex的不得了线程,不然mutex对象的图景就能发生变动,此外,Mutex对象保险着二个递归计数,提出全部该Mutex的线程拥有了它稍微次,若是八个线程当前抱有三个mutex,而后该线程再一次在mutex上等候,计数就能够递增,那一个线程允许继续运维。

协会Mutex的递归锁:

 1 class MutexLock : IDisposable
 2     {
 3          private readonly Mutex mutex;
 4 
 5          public MutexLock()
 6         {
 7             mutex = new Mutex();
 8         }
 9 
10         public void Enter()
11         {
12             mutex.WaitOne();
13             //随便坐任何事情
14             Leave();
15             mutex.ReleaseMutex();
16 
17         }
18 
19         public void Leave()
20         {
21             mutex.WaitOne();
22             //随便坐任何事情
23             mutex.ReleaseMutex();
24         }
25 
26         public void Dispose()
27         {
28             mutex.Dispose();
29         }
30     }

 

内核方式结构
前篇大家早就提过,内核情势组织比用户情势结构慢繁多,二个原因是它们要求…

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 澳门新葡亰官网app 版权所有