Mutex

A Mutex is like a C# lock, but it can work across multiple processes. In other words, Mutex can be computer-wide as well as application-wide.

Acquiring and releasing an uncontended Mutex takes a few microseconds—about 50 times slower than a lock.

HANDLE CreateMutex(

   LPSECURITY_ATTRIBUTES lpMutexAttributes,

   BOOL bInitialOwner,

   LPCTSTR lpName

);

这就是他为什么能跨进程访问的原因，正是由于它使用P/Invoke，他的效率问题就凸现出来，明显不如Monitor之类的快，用的时候还需多多斟酌。

 A mutex is a mutually exclusive synchronization object. This means it can be acquired by

one and only one thread at a time. The mutex is designed for those situations in which a

shared resource can be used by only one thread at a time. For example, imagine a log file

that is shared by several processes, but only one process can write to that file at any one

time. A mutex is the perfect synchronization device to handle this situation.

The mutex is supported by the System.Threading.Mutex class. It has several constructors. Two commonly used ones are shown here:

public Mutex( )

public Mutex(bool initiallyOwned)

The first version creates a mutex that is initially unowned. In the second version, if

initiallyOwned is true, the initial state of the mutex is owned by the calling thread.

Otherwise, it is unowned.

To acquire the mutex, your code will call WaitOne( ) on the mutex. This method

is inherited by Mutex from the Thread.WaitHandle class. Here is its simplest form:

public bool WaitOne( );

It waits until the mutex on which it is called can be acquired. Thus, it blocks execution of the

calling thread until the specified mutex is available. It always returns true.

When your code no longer needs ownership of the mutex, it releases it by calling

ReleaseMutex( ), shown here:

public void ReleaseMutex( )

This releases the mutex on which it is called, enabling the mutex to be acquired by another

thread.

Mutex myMtx = new Mutex();

// ...

myMtx.WaitOne(); // wait to acquire the mutex

// Access the shared resource.

myMtx.ReleaseMutex(); // release the mutex

 When the call to WaitOne( ) takes place, execution of the thread will suspend until the mutex can be acquired. When the call to ReleaseMutex( ) takes place, the mutex is released and another thread can acquire it. Using this approach, access to a shared resource can be limited to one thread at a time.

The mutex created by the previous example is known only to the process that creates it.However, it is possible to create a mutex that is known systemwide. To do so, you mustcreate a named mutex, using one of these constructors:

public Mutex(bool initiallyOwned, string name)

public Mutex(bool initiallyOwned, string name, out bool createdNew)

In both forms, the name of the mutex is passed in name. In the first form, if initiallyOwned is true, then ownership of the mutex is requested. However, because a systemwide mutex might already be owned by another process, it is better to specify false for this parameter. 

In the second form, on return createdNew will be true if ownership was requested and acquired. It will be false if ownership was denied. (There is also a third form of the Mutex constructor that allows you to specify a MutexSecurity object, which controls access.) Using a named mutex enables you to manage interprocess synchronization.

One other point: It is legal for a thread that has acquired a mutex to make one or more additional calls to WaitOne( ) prior to calling ReleaseMutex( ), and these additional calls will succeed. That is, redundant calls to WaitOne( ) will not block a thread that already owns the mutex. However, the number of calls to WaitOne( ) must be balanced by the same number of calls to ReleaseMutex( ) before the mutex is released.

本文转自cnn23711151CTO博客，原文链接：http://blog.51cto.com/cnn237111/515758 ，如需转载请自行联系原作者