First of all, one thing is certain: Microsoft's Framework Class Library (FCL) ensures that all static methods are thread-safe.

FCL does not guarantee that instance methods are thread-safe. Because if all locks are added, it will cause a huge loss of performance. In addition, if each instance method needs to acquire and release a lock, in fact, you will end up with only one thread running in your application at any given moment, which has an obvious impact on performance.

The following introduces the primitive thread synchronization construct.

Primitive: refers to the simplest construct that can be used in code. There are two primitive constructs: user-mode and kernel-mode.

User mode

Special CPU instructions are used to coordinate threads.

Technology: volatile keyword, Interlocked class (interlock), spinlock (spin lock)

Common lock ①: volatile keyword indicates that a field can be modified by multiple threads executing simultaneously . Fields declared volatile are not subject to compiler optimizations (assuming access by a single thread). This ensures that the field presents the latest value at any time.

Interlocked class: Provides atomic operations for variables shared by multiple threads. . The so-called atomic operation refers to an operation that will not be interrupted by the thread scheduling mechanism; once this operation starts, it will run until the end without any context switch (switch to another thread) in the middle.

Common lock ②: The SpinLock structure is a low-level mutex synchronization primitive that rotates while waiting to acquire the lock. On multi-core computers, SpinLock will perform better than other lock types when wait times are expected to be short and contention conditions are rare. Even if SpinLock does not acquire the lock, it generates the thread's time slice. It does this to avoid thread priority inversion and to enable the garbage collector to continue executing. When using SpinLock, make sure that no thread holds the lock for more than a very short period of time, and that no thread blocks while holding the lock.

Advantages:

Primitive user-mode constructs should be used whenever possible, as they are significantly faster than kernel-mode constructs.

Coordination of threads occurs in hardware (that's why it's so fast).

But the Microsoft Windows operating system never detects that a thread is blocked on a primitive user-mode construct.

Because a thread pool blocking on a user-mode primitive construct is never considered blocked, the thread pool will not create a new thread to replace such a temporary thread.

These CPU instructions only block the thread for a relatively short time.

Disadvantages:

Only the Windows operating system kernel can stop a thread from running (preventing it from wasting CPU time).

Threads running in user mode may be preempted by the system, but the threads will be scheduled again as quickly as possible.

Threads that want to obtain resources but cannot obtain them temporarily will continue to "spin" in user mode, which may waste a lot of CPU time. Threads are always running on one CPU, which we call "livelock".

Example:

using System;using System.Threading;public class Worker
{    // This method is called when the thread is started.
    public void DoWork()
    {        while (!_shouldStop)
        {
            Console.WriteLine("Worker thread: working...");
        }
        Console.WriteLine("Worker thread: terminating gracefully.");
    }    public void RequestStop()
    {
        _shouldStop = true;
    }    // Keyword volatile is used as a hint to the compiler that this data
    // member is accessed by multiple threads.
    private volatile bool _shouldStop;
}public class WorkerThreadExample
{    static void Main()
    {        // Create the worker thread object. This does not start the thread.
        Worker workerObject = new Worker();
        Thread workerThread = new Thread(workerObject.DoWork);        // Start the worker thread.
        workerThread.Start();
        Console.WriteLine("Main thread: starting worker thread...");        // Loop until the worker thread activates.
        while (!workerThread.IsAlive) ;        // Put the main thread to sleep for 1 millisecond to
        // allow the worker thread to do some work.
        Thread.Sleep(1);        // Request that the worker thread stop itself.
        workerObject.RequestStop();        // Use the Thread.Join method to block the current thread 
        // until the object's thread terminates.
        workerThread.Join();
        Console.WriteLine("Main thread: worker thread has terminated.");
    }    // Sample output:
    // Main thread: starting worker thread...
    // Worker thread: working...
    // Worker thread: working...
    // Worker thread: working...
    // Worker thread: working...
    // Worker thread: working...
    // Worker thread: working...
    // Worker thread: terminating gracefully.
    // Main thread: worker thread has terminated.}

Kernel mode

Provided by the Windows operating system itself. They require calling functions implemented by the operating system kernel in the application's thread.

Technology: EventWaitHandle (event), Semaphore (semaphore), Mutex (mutex)

System.Object??
System.MarshalByRefObject????
System.Threading.WaitHandle??????
System.Threading.EventWaitHandle??????
System.Threading.Mutex??????
System.Threading.Semaphore

Common lock ③: The Mutex class is a wrapper of the Win32 construct, which can cross application domains Boundaries are marshaled, can be used for multiple waits, and can be used to synchronize threads in different processes.

Advantages:

When a thread acquires resources owned by other threads through kernel-mode constructs, Windows blocks the thread to prevent it from wasting CPU time. When the resource becomes available, Windows resumes the thread, allowing it to access the resource. It does not occupy a CPU "spin".

Allows native and managed threads to be synchronized with each other.

Can synchronize threads running in different processes on the same machine.

Security settings can be applied to prevent unauthorized accounts from accessing them.

The thread can block until all kernel-mode constructs it is cooperating with are available, or until any kernel-mode construct in the set is available.

Threads blocked on kernel mode constructs can specify a timeout value: if the desired resource cannot be accessed within the specified time, the thread can be unblocked and perform other tasks.

Disadvantages:

Switching a thread from user mode to kernel mode (or vice versa) incurs a huge performance penalty, which is why kernel constructs should be avoided. In addition, if the thread is blocked all the time, it will lead to "deadlock" (deadlock).

Deadlock is always due to livelock, because livelock wastes CPU time and wastes memory (thread stack, etc.), while deadlock only wastes memory.

Mixed construction

兼具上面兩者的長處。在沒有競爭的情況下，快而且不會阻塞（就像用戶模式）。在有競爭的情況，希望它被操作系統(tǒng)內(nèi)核阻塞。

技術(shù)：ManualResetEventSlim類、SemaphoreSlim類、Monitor類、Lock類、ReaderWriterLockSlim類、CountdownEvent類、Barrier類、雙檢鎖.

常見鎖④：Monitor 通常更為可取，因為監(jiān)視器是專門為 .NET Framework 而設(shè)計的，因而它比Mutex可以更好地利用資源。盡管 mutex 比監(jiān)視器更為強大，但是相對于 Monitor 類，它所需要的互操作轉(zhuǎn)換更消耗計算資源。

常見鎖⑤：使用 lock (C#) 或 SyncLock (Visual Basic) 關(guān)鍵字是Monitor的封裝。通常比直接使用 Monitor 類更可取，一方面是因為 lock 或 SyncLock 更簡潔，另一方面是因為lock 或 SyncLock 確保了即使受保護(hù)的代碼引發(fā)異常，也可以釋放基礎(chǔ)監(jiān)視器。

常見鎖⑥：ReaderWriterLock 鎖，在某些情況下，可能希望只在寫入數(shù)據(jù)時鎖定資源，在不更新數(shù)據(jù)時允許多個客戶端同時讀取數(shù)據(jù)。ReaderWriterLock 類在線程修改資源時將強制其獨占訪問資源，但在讀取資源時則允許非獨占訪問。 ReaderWriter 鎖可用于代替排它鎖。使用排它鎖時，即使其他線程不需要更新數(shù)據(jù)，也會讓這些線程等待。

雙檢鎖

常見鎖⑦：雙重檢查鎖定模式（也被稱為”雙重檢查加鎖優(yōu)化”，”鎖暗示”（Lock hint）) 是一種軟件設(shè)計模式用來減少并發(fā)系統(tǒng)中競爭和同步的開銷。

雙重檢查鎖定模式首先驗證鎖定條件(第一次檢查)，只有通過鎖定條件驗證才真正的進(jìn)行加鎖邏輯并再次驗證條件(第二次檢查)。

它通常用于減少加鎖開銷，尤其是為多線程環(huán)境中的單例模式實現(xiàn)“惰性初始化”。惰性初始化的意思是直到第一次訪問時才初始化它的值。

public sealed class Singleton
    {        private static volatile Singleton instance = null;        
private static object syncRoot = new Object();        
private static int count = 100;        
private Singleton() { }        
public static Singleton Instance
        {            get
            {                if (instance == null)
                {                    lock (syncRoot)
                    {                        if (instance == null)
                            instance = new Singleton();
                    }
                }                return instance;
            }
        }        public static Singleton GetSingleton()
        {            if (instance == null)
            {                lock (syncRoot)
                {                    if (instance == null)
                    {
                        instance = new Singleton();
                    }                        
                }
            }            return instance;
        }        public override string ToString()
        {            lock (syncRoot)
            {                int buf = --count;
                Thread.Sleep(20);                return buf + "_" + count.ToString();
            }
        }
    }static void Main(string[] args)
        {
            Task<string>[] tasks = new Task<string>[10];
            Stopwatch watch = new Stopwatch();            object syncRoot = new Object();
            watch.Start();            for (int i = 0; i < tasks.Length; i++)
            {
                tasks[i] = Task.Factory.StartNew<string>(() =>(Singleton.GetSingleton().ToString()));                    
            }
            Task.WaitAll(tasks, 5000);//設(shè)置超時5s
            watch.Stop();
            Console.WriteLine("Tasks running need " + watch.ElapsedMilliseconds + " ms." + "\n");            
for (int i = 0; i < tasks.Length; i++)
            {                //超時處理
                if (tasks[i].Status != TaskStatus.RanToCompletion)
                {
                    Console.WriteLine("Task {0} Error!", i + 1);
                }                else
                {                    //save result
                    Console.WriteLine("Tick ID is " + tasks[i].Result);
                    Console.WriteLine();
                }
            }            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine("Main thread do work!");
                Thread.Sleep(200);
            }

            Console.ReadKey();
        }

輸出：

Tasks running need 298 ms.

Tick ID is 96_96

Tick ID is 99_99

Tick ID is 97_97

Tick ID is 98_98

Tick ID is 95_95

Tick ID is 94_94

Tick ID is 93_93

Tick ID is 92_92

Tick ID is 91_91

Tick ID is 90_90

Main thread do work!
Main thread do work!
Main thread do work!

以上就是從0自學(xué)C#12--線程同步解決方法匯總以及優(yōu)缺點的內(nèi)容，更多相關(guān)內(nèi)容請關(guān)注PHP中文網(wǎng)（www.miracleart.cn）！