C# 多线程 - 告诉等待进程第一个进程已完成使用锁定代码？

发布于 2024-08-11 01:06:06 字数 107 浏览 3 评论 0 原文

据我所知，在开发多线程应用程序时，您必须使用监视器或锁来同步对共享内存的访问。

问题

如何告诉等待进程（proc2）使用锁定代码块（proc1）的进程已完成使用该代码？

原文

分享到QQ

分享到微博

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

发布评论

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

铜锣湾横着走 2024-08-18 01:06:06

您是在谈论真正的操作系统进程，还是只是进程中的任务？

如果只是流程中的任务，您通常只需让锁为您完成工作。第二个任务尝试获取第一个任务当前拥有的锁，但只是阻塞。当第一个任务释放锁时，第二个任务会自动解锁。

如果您希望第二个线程可以选择先执行其他工作，您可以使用 Monitor.TryEnter 代替 - 尽管这稍微麻烦一些。

如果您想等待，但您有比锁定更复杂的要求，那么可能需要使用 Monitor.Pulse/PulseAll/Wait。有关示例，请参阅此页面的后半部分。

如果您实际上谈论的是进程，那么您需要使用系统范围的结构，例如互斥体。它们比进程内 .NET 监视器“更重”，但允许进程间协调。

回复收藏 0 原文

迷路的信 2024-08-18 01:06:06

另一个进程通常被阻塞，等待获取锁。当第一个进程释放它时，第二个进程就可以抓住它。

换句话说，在典型的场景中，您不会“告诉”另一个线程运行，而是停止阻止它运行。

（在某些情况下，您确实希望告诉线程继续运行，通常由 AutoResetEvent 或 ManualResetEvent 处理）

回复收藏 0 原文

究竟谁懂我的在乎 2024-08-18 01:06:06

为此，您需要使用 C# 中提供的各种同步对象。可用同步对象的一些示例是 System.Threading.Mutex< /a>, System.Threading.Semaphore, System.Threading.ManualResetEvent 和 System.Threading.AutoResetEvent（这不是详尽的列表，但这是基础）。您需要的确切同步对象取决于您的特定需求。

互斥锁可能是最简单的使用方式，所以我将举个例子。假设我有两个函数在两个不同的线程中运行（我将坚持使用您自己的示例，proc1 和 proc2）。两个函数都需要访问同一个变量 foo。在每个访问 foo 的函数中，您需要首先“锁定”互斥体。然后做任何你需要做的事情，然后解锁。

例如：

class bar
{
  private int foo;
  private System.Threading.Mutex lock = new System.Threading.Mutex;

  public void proc1()
  {
    lock.WaitOne();

    // do stuff to foo

    lock.ReleaseMutex();
  }

  public void proc2()
  {
    lock.WaitOne();

    // do stuff to foo

    lock.ReleaseMutex();
  }
};

使用该方法，proc1将执行。它会尝试“抓住”互斥锁（锁）。如果互斥锁已被占用，proc1 将进入睡眠状态，直到互斥锁被另一个线程“释放” - proc1 将坐下来等待，不执行任何操作（并且不占用任何 CPU 周期！），直到互斥锁被释放。然后它会锁定它并做它的事情。在 proc1 完成使用互斥锁之前，其他线程都无法获取该互斥锁。

另一种选择是使用事件。 C# 提供两种类型的事件 - 手动重置和自动重置。我将在我的示例中使用手动重置事件。

class bar
{
  private System.Threading.ManualResetEvent event = new System.Threading.ManualResetEvent;

  public void proc1()
  {
    // do stuff

    event.Set();
  }

  public void proc2()
  {
    event.WaitOne();
    event.Reset();

    // do stuff
  }
};

在此示例中，当 proc2 运行时，它会在遇到“event.WaitOne”时进入睡眠状态，并且不使用任何 CPU 周期，直到 proc1“设置”该事件。设置事件会导致 proc2 唤醒，现在它可以做它的事情了。因为这是一个手动重置事件，所以该事件将保持在“设置”状态，直到调用 event.Reset() 为止。

To do this, you'll need to make use of the various synchronization objects available in C#. Some examples of the available synchronization objects are System.Threading.Mutex, System.Threading.Semaphore, System.Threading.ManualResetEvent, and System.Threading.AutoResetEvent (this is not an exhaustive list, but it's the basics). The exact synchronization object you'll want depends on your specific needs.

Mutex is probably the simplest to use, so I'll give it as an example. Say I have two functions that are running in two different threads (I'll stick with your own examples, proc1 and proc2). Both functions need to access the same variable, foo. In each function that accesses foo, you'll need to "lock" your mutex first. Then do whatever you need to do, then unlock it.

For example:

class bar
{
  private int foo;
  private System.Threading.Mutex lock = new System.Threading.Mutex;

  public void proc1()
  {
    lock.WaitOne();

    // do stuff to foo

    lock.ReleaseMutex();
  }

  public void proc2()
  {
    lock.WaitOne();

    // do stuff to foo

    lock.ReleaseMutex();
  }
};

Using this method, proc1 will execute. It will try to "grab" the mutex (lock). If the mutex is already grabbed, proc1 will go to sleep until the mutex is "released" by the other thread - proc1 will sit and wait, doing nothing (and eating no CPU cycles!) until the mutex is released. Then it will lock it and do its thing. No other thread will be able to grab the mutex until proc1 is done with it.

Another option is to use an Event. C# provides two types of events - manual reset and autoreset. I'll use a manual reset event for my example.

class bar
{
  private System.Threading.ManualResetEvent event = new System.Threading.ManualResetEvent;

  public void proc1()
  {
    // do stuff

    event.Set();
  }

  public void proc2()
  {
    event.WaitOne();
    event.Reset();

    // do stuff
  }
};

In this example, when proc2 is running it goes to sleep when it hits "event.WaitOne" and uses no CPU cycles until proc1 "sets" the event. Setting the event causes proc2 to wake up, and now it can do its thing. Because this is a manual reset event, the event will stay in the "set" state until event.Reset() is called.

回复收藏 0 原文