C# concurrency semaphore parallel-processing

最简单的并发模式

发布于 2024-10-21 21:05:21 字数 416 浏览 1 评论 0原文

请您帮我提醒我最简单的并行编程技术之一。

我如何在 C# 中执行以下操作：

初始状态：

semaphore counter = 0

线程 1：

// Block until semaphore is signalled
semaphore.Wait(); // wait until semaphore counter is 1

线程 2：

// Allow thread 1 to run:
semaphore.Signal(); // increments from 0 to 1

它不是互斥锁，因为没有临界区，或者更确切地说，您可以说存在无限临界区。那么它是什么？

原文

Please, would you help me in reminding me of one of the simplest parallel programming techniques.

How do I do the following in C#:

Initial state:

semaphore counter = 0

Thread 1:

// Block until semaphore is signalled
semaphore.Wait(); // wait until semaphore counter is 1

Thread 2:

// Allow thread 1 to run:
semaphore.Signal(); // increments from 0 to 1

It's not a mutex because there is no critical section, or rather you can say there is an infinite critical section. So what is it?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

不爱素颜 2024-10-28 21:05:22

关于“如何”...好吧，您可以使用信号量< /a>、互斥体或重置事件 (< a href="http://msdn.microsoft.com/en-us/library/system.threading.manualresetevent.aspx" rel="nofollow">ManualResetEvent，AutoResetEvent），但我个人使用 Monitor 来实现；

object sync = new object();

线程 1:

lock(sync) { // blocks until it successfully takes (re-entrant) lock on sync
    // here: launch thread 2, to ensure thread 1 has the lock first
    Monitor.Wait(sync); // releases lock(s) and waits for pulse,
                        // then retakes locks(s) when free
} // releases lock (or decrement by 1)

线程 2:

lock(sync) { // blocks until it successfully takes (re-entrant) lock on sync
    Monitor.Pulse(sync); // moves a waiting thread into the ready-queue
                         // (but the awoken thread still can't continue until
                         // it gets the lock itself - and we still hold it)
} // releases lock (or decrement by 1)

Re "how"... well, you could use a Semaphore, Mutex or reset-event (ManualResetEvent, AutoResetEvent), but personally I use Monitor for that;

object sync = new object();

thread 1:

lock(sync) { // blocks until it successfully takes (re-entrant) lock on sync
    // here: launch thread 2, to ensure thread 1 has the lock first
    Monitor.Wait(sync); // releases lock(s) and waits for pulse,
                        // then retakes locks(s) when free
} // releases lock (or decrement by 1)

thread 2:

lock(sync) { // blocks until it successfully takes (re-entrant) lock on sync
    Monitor.Pulse(sync); // moves a waiting thread into the ready-queue
                         // (but the awoken thread still can't continue until
                         // it gets the lock itself - and we still hold it)
} // releases lock (or decrement by 1)

回复收藏 0 原文