2. 程式人生 > >歸納一下:C#執行緒同步的幾種方法

歸納一下:C#執行緒同步的幾種方法

阿新 • • 發佈：2018-11-19

　我們在程式設計的時候，有時會使用多執行緒來解決問題，比如你的程式需要在後臺處理一大堆資料，但還要使使用者介面處於可操作狀態；或者你的程式需要訪問一些外部資源如資料庫或網路檔案等。這些情況你都可以建立一個子執行緒去處理，然而，多執行緒不可避免地會帶來一個問題，就是執行緒同步的問題。如果這個問題處理不好，我們就會得到一些非預期的結果。

　　在網上也看過一些關於執行緒同步的文章，其實執行緒同步有好幾種方法，下面我就簡單的做一下歸納。

　　一、volatile關鍵字

　　volatile是最簡單的一種同步方法，當然簡單是要付出代價的。它只能在變數一級做同步，volatile的含義就是告訴處理器， 不要將我放入工作記憶體， 請直接在主存操作我。（【轉自

www.bitsCN.com 】）因此，當多執行緒同時訪問該變數時，都將直接操作主存，從本質上做到了變數共享。

　　能夠被標識為volatile的必須是以下幾種型別：（摘自MSDN）

  • Any reference type.
  • Any pointer type (in an unsafe context).
  • The types sbyte, byte, short, ushort, int, uint, char, float, bool.
  • An enum type with an enum base type of byte, sbyte, short, ushort, int, or uint.

　　如：

複製程式碼   Code 
public class A
{
private volatile int _i;
public int I
{
get { return _i; }
set { _i = value; }
}
} 
 
 
  複製程式碼
  
 

　　但volatile並不能實現真正的同步，因為它的操作級別只停留在變數級別，而不是原子級別。如果是在單處理器系統中，是沒有任何問題的，變數在主存中沒有機會被其他人修改，因為只有一個處理器，這就叫作processor Self-Consistency。但在多處理器系統中，可能就會有問題。 每個處理器都有自己的data cach，而且被更新的資料也不一定會立即寫回到主存。所以可能會造成不同步，但這種情況很難發生，因為cach的讀寫速度相當快，flush的頻率也相當高，只有在壓力測試的時候才有可能發生，而且機率非常非常小。
 
 

　　二、lock關鍵字
 

　　lock是一種比較好用的簡單的執行緒同步方式，它是通過為給定物件獲取互斥鎖來實現同步的。它可以保證當一個執行緒在關鍵程式碼段的時候，另一個執行緒不會進來，它只能等待，等到那個執行緒物件被釋放，也就是說執行緒出了臨界區。用法：
 
 
 
  複製程式碼
  
  
 Code 
public void Function() 
{
object lockThis = new object (); 
lock (lockThis)
{
// Access thread-sensitive resources. 
}
} 
 
 
 
  複製程式碼
  
 

 
 

 
 

 
 

　　lock的引數必須是基於引用型別的物件，不要是基本型別像bool,int什麼的，這樣根本不能同步，原因是lock的引數要求是物件，如果傳入int，勢必要發生裝箱操作，這樣每次lock的都將是一個新的不同的物件。最好避免使用public型別或不受程式控制的物件例項，因為這樣很可能導致死鎖。特別是不要使用字串作為lock的引數，因為字串被CLR“暫留”，就是說整個應用程式中給定的字串都只有一個例項，因此更容易造成死鎖現象。建議使用不被“暫留”的私有或受保護成員作為引數。其實某些類已經提供了專門用於被鎖的成員，比如Array型別提供SyncRoot，許多其它集合型別也都提供了SyncRoot。
 

 
 

　　所以，使用lock應該注意以下幾點：　
 

　　１、如果一個類的例項是public的，最好不要lock(this)。因為使用你的類的人也許不知道你用了lock，如果他new了一個例項，並且對這個例項上鎖，就很容易造成死鎖。
 

　　２、如果MyType是public的，不要lock(typeof(MyType))
 

　　３、永遠也不要lock一個字串
 

　　三、System.Threading.Interlocked
 

　　對於整數資料型別的簡單操作，可以用 Interlocked 類的成員來實現執行緒同步，存在於System.Threading名稱空間。Interlocked類有以下方法：Increment ,Decrement , Exchange 和CompareExchange 。使用Increment 和Decrement 可以保證對一個整數的加減為一個原子操作。Exchange 方法自動交換指定變數的值。CompareExchange 方法組合了兩個操作：比較兩個值以及根據比較的結果將第三個值儲存在其中一個變數中。比較和交換操作也是按原子操作執行的。如：
 
 
 
  複製程式碼
  
  
 Code 
int i = 0 ;
System.Threading.Interlocked.Increment( ref i);
Console.WriteLine(i);
System.Threading.Interlocked.Decrement( ref i);
Console.WriteLine(i);
System.Threading.Interlocked.Exchange( ref i, 100 );
Console.WriteLine(i);
System.Threading.Interlocked.CompareExchange( ref i, 10 , 100 ); 
 
 
 
  複製程式碼
  
 

Output:
 

 

　　四、Monitor
 

　　Monitor類提供了與lock類似的功能,不過與lock不同的是,它能更好的控制同步塊,當呼叫了Monitor的Enter(Object o)方法時,會獲取o的獨佔權,直到呼叫Exit(Object o)方法時,才會釋放對o的獨佔權,可以多次呼叫Enter(Object o)方法,只需要呼叫同樣次數的Exit(Object o)方法即可,Monitor類同時提供了TryEnter(Object o,[int])的一個過載方法,該方法嘗試獲取o物件的獨佔權,當獲取獨佔權失敗時,將返回false。
 

　　但使用 lock 通常比直接使用 Monitor 更可取，一方面是因為 lock 更簡潔，另一方面是因為 lock 確保了即使受保護的程式碼引發異常，也可以釋放基礎監視器。這是通過 finally 中呼叫Exit來實現的。事實上，lock 就是用 Monitor 類來實現的。下面兩段程式碼是等效的：
 
 
 
  複製程式碼
  
  
 Code 
lock (x)
{
DoSomething();
} 
 
 
 等效於

object obj = ( object )x;
System.Threading.Monitor.Enter(obj);
try 
{
DoSomething();
}
finally 
{
System.Threading.Monitor.Exit(obj);
} 
 
 
 
  複製程式碼
  
 

 
 

關於用法，請參考下面的程式碼：
 
 
 
  複製程式碼
  
  
 Code 
private static object m_monitorObject = new object ();
[STAThread]
static void Main( string [] args)
{
Thread thread = new Thread( new ThreadStart(Do));
thread.Name = " Thread1 " ;
Thread thread2 = new Thread( new ThreadStart(Do));
thread2.Name = " Thread2 " ;
thread.Start();
thread2.Start();
thread.Join();
thread2.Join();
Console.Read();
}
static void Do()
{
if ( ! Monitor.TryEnter(m_monitorObject))
{
Console.WriteLine( " Can't visit Object " + Thread.CurrentThread.Name);
return ;
}
try 
{
Monitor.Enter(m_monitorObject);
Console.WriteLine( " Enter Monitor " + Thread.CurrentThread.Name);
Thread.Sleep( 5000 );
}
finally 
{
Monitor.Exit(m_monitorObject);
}
} 
 
 
 
  複製程式碼
  
 

　　當執行緒1獲取了m_monitorObject物件獨佔權時，執行緒2嘗試呼叫TryEnter(m_monitorObject)，此時會由於無法獲取獨佔權而返回false，輸出資訊如下：
 

　　另外，Monitor還提供了三個靜態方法Monitor.Pulse(Object o)，Monitor.PulseAll(Object o)和Monitor.Wait(Object o ) ，用來實現一種喚醒機制的同步。關於這三個方法的用法，可以參考MSDN，這裡就不詳述了。
 

　　五、Mutex
 

　　在使用上,Mutex與上述的Monitor比較接近，不過Mutex不具備Wait，Pulse，PulseAll的功能，因此，我們不能使用Mutex實現類似的喚醒的功能。不過Mutex有一個比較大的特點，Mutex是跨程序的，因此我們可以在同一臺機器甚至遠端的機器上的多個程序上使用同一個互斥體。儘管Mutex也可以實現程序內的執行緒同步，而且功能也更強大，但這種情況下，還是推薦使用Monitor，因為Mutex類是win32封裝的，所以它所需要的互操作轉換更耗資源。
 

　　六、ReaderWriterLock
 

　　在考慮資源訪問的時候,慣性上我們會對資源實施lock機制,但是在某些情況下,我們僅僅需要讀取資源的資料,而不是修改資源的資料,在這種情況下獲取資源的獨佔權無疑會影響執行效率,因此.Net提供了一種機制,使用ReaderWriterLock進行資源訪問時,如果在某一時刻資源並沒有獲取寫的獨佔權,那麼可以獲得多個讀的訪問權,單個寫入的獨佔權,如果某一時刻已經獲取了寫入的獨佔權,那麼其它讀取的訪問權必須進行等待,參考以下程式碼：
 
 
 
  複製程式碼
  
 
 Code
private static ReaderWriterLock m_readerWriterLock = new ReaderWriterLock();
private static int m_int = 0;
[STAThread]
static void Main(string[] args)
{
Thread readThread = new Thread(new ThreadStart(Read));
readThread.Name = "ReadThread1";
Thread readThread2 = new Thread(new ThreadStart(Read));
readThread2.Name = "ReadThread2";
Thread writeThread = new Thread(new ThreadStart(Writer));
writeThread.Name = "WriterThread";
readThread.Start();
readThread2.Start();
writeThread.Start();
readThread.Join();
readThread2.Join();
writeThread.Join();

Console.ReadLine(); 
}
private static void Read()
{
while (true)
{
Console.WriteLine("ThreadName " + Thread.CurrentThread.Name + " AcquireReaderLock");
m_readerWriterLock.AcquireReaderLock(10000);
Console.WriteLine(String.Format("ThreadName : {0} m_int : {1}", Thread.CurrentThread.Name, m_int));
m_readerWriterLock.ReleaseReaderLock();
}
}

private static void Writer()
{
while (true)
{
Console.WriteLine("ThreadName " + Thread.CurrentThread.Name + " AcquireWriterLock");
m_readerWriterLock.AcquireWriterLock(1000);
Interlocked.Increment(ref m_int);
Thread.Sleep(5000);
m_readerWriterLock.ReleaseWriterLock();
Console.WriteLine("ThreadName " + Thread.CurrentThread.Name + " ReleaseWriterLock");
}
} 
 
 
 
  複製程式碼
  
 

在程式中,我們啟動兩個執行緒獲取m_int的讀取訪問權,使用一個執行緒獲取m_int的寫入獨佔權,執行程式碼後,輸出如下：
 

 

可以看到，當WriterThread獲取到寫入獨佔權後，任何其它讀取的執行緒都必須等待，直到WriterThread釋放掉寫入獨佔權後，才能獲取到資料的訪問權，應該注意的是，上述列印資訊很明顯顯示出，可以多個執行緒同時獲取資料的讀取權，這從ReadThread1和ReadThread2的資訊互動輸出可以看出。
 

　　七、SynchronizationAttribute
 

　　當我們確定某個類的例項在同一時刻只能被一個執行緒訪問時，我們可以直接將類標識成Synchronization的，這樣，CLR會自動對這個類實施同步機制,實際上，這裡面涉及到同步域的概念，當類按如下設計時，我們可以確保類的例項無法被多個執行緒同時訪問
　　1). 在類的宣告中,新增System.Runtime.Remoting.Contexts.SynchronizationAttribute屬性。
    2). 繼承至System.ContextBoundObject
    需要注意的是，要實現上述機制，類必須繼承至System.ContextBoundObject，換句話說,類必須是上下文繫結的。
    一個示範類程式碼如下：
 

 
 Code
[System.Runtime.Remoting.Contexts.Synchronization]
public class SynchronizedClass : System.ContextBoundObject
{

} 
 
 
 

 
 

　　八、MethodImplAttribute
 

　　如果臨界區是跨越整個方法的，也就是說，整個方法內部的程式碼都需要上鎖的話，使用MethodImplAttribute屬性會更簡單一些。這樣就不用在方法內部加鎖了，只需要在方法上面加上 [MethodImpl(MethodImplOptions.Synchronized)] 就可以了，MehthodImpl和MethodImplOptions都在名稱空間System.Runtime.CompilerServices 裡面。但要注意這個屬性會使整個方法加鎖，直到方法返回，才釋放鎖。因此，使用上不太靈活。如果要提前釋放鎖，則應該使用Monitor或lock。我們來看一個例子：
 
 
 
  複製程式碼
  
  
 Code 
[MethodImpl(MethodImplOptions.Synchronized)]
public void DoSomeWorkSync()
{
Console.WriteLine( " DoSomeWorkSync() -- Lock held by Thread " + 
Thread.CurrentThread.GetHashCode());
Thread.Sleep( 1000 );
Console.WriteLine( " DoSomeWorkSync() -- Lock released by Thread " + 
Thread.CurrentThread.GetHashCode());
}
public void DoSomeWorkNoSync()
{
Console.WriteLine( " DoSomeWorkNoSync() -- Entered Thread is " + 
Thread.CurrentThread.GetHashCode());
Thread.Sleep( 1000 );
Console.WriteLine( " DoSomeWorkNoSync() -- Leaving Thread is " + 
Thread.CurrentThread.GetHashCode());
}

[STAThread]
static void Main( string [] args)
{
MethodImplAttr testObj = new MethodImplAttr();
Thread t1 = new Thread( new ThreadStart(testObj.DoSomeWorkNoSync));
Thread t2 = new Thread( new ThreadStart(testObj.DoSomeWorkNoSync));
t1.Start();
t2.Start();
Thread t3 = new Thread( new ThreadStart(testObj.DoSomeWorkSync));
Thread t4 = new Thread( new ThreadStart(testObj.DoSomeWorkSync));
t3.Start();
t4.Start();

Console.ReadLine(); 
} 
 
 
 
  複製程式碼
  
 

這裡，我們有兩個方法，我們可以對比一下，一個是加了屬性MethodImpl的DoSomeWorkSync()，一個是沒加的DoSomeWorkNoSync()。在方法中Sleep(1000)是為了在第一個執行緒還在方法中時，第二個執行緒能夠有足夠的時間進來。對每個方法分別起了兩個執行緒，我們先來看一下結果：
 

 

可以看出，對於執行緒１和２，也就是呼叫沒有加屬性的方法的執行緒，當執行緒２進入方法後，還沒有離開，執行緒１有進來了，這就是說，方法沒有同步。我們再來看看執行緒３和４，當執行緒３進來後，方法被鎖，直到執行緒３釋放了鎖以後，執行緒４才進來。
 

　　九、同步事件和等待控制代碼
 

　　用lock和Monitor可以很好地起到執行緒同步的作用，但它們無法實現執行緒之間傳遞事件。如果要實現執行緒同步的同時，執行緒之間還要有互動，就要用到同步事件。同步事件是有兩個狀態（終止和非終止）的物件，它可以用來啟用和掛起執行緒。
 

　　同步事件有兩種：AutoResetEvent和 ManualResetEvent。它們之間唯一不同的地方就是在啟用執行緒之後，狀態是否自動由終止變為非終止。AutoResetEvent自動變為非終止，就是說一個AutoResetEvent只能啟用一個執行緒。而ManualResetEvent要等到它的Reset方法被呼叫，狀態才變為非終止，在這之前，ManualResetEvent可以啟用任意多個執行緒。
 

　　可以呼叫WaitOne、WaitAny或WaitAll來使執行緒等待事件。它們之間的區別可以檢視MSDN。當呼叫事件的 Set方法時，事件將變為終止狀態，等待的執行緒被喚醒。
 

　　來看一個例子，這個例子是MSDN上的。因為事件只用於一個執行緒的啟用，所以使用 AutoResetEvent 或 ManualResetEvent 類都可以。
 
 
 
  複製程式碼
  
 
 Code
static AutoResetEvent autoEvent;

static void DoWork()
{
Console.WriteLine(" worker thread started, now waiting on event");
autoEvent.WaitOne();
Console.WriteLine(" worker thread reactivated, now exiting");
}

[STAThread]
static void Main(string[] args)
{
autoEvent = new AutoResetEvent(false);

Console.WriteLine("main thread starting worker thread");
Thread t = new Thread(new ThreadStart(DoWork));
t.Start();

Console.WriteLine("main thrad sleeping for 1 second");
Thread.Sleep(1000);

Console.WriteLine("main thread signaling worker thread");
autoEvent.Set();

Console.ReadLine(); 
} 
 
 
 
  複製程式碼
  
 

我們先來看一下輸出：
 

 

在主函式中，首先建立一個AutoResetEvent的例項，引數false表示初始狀態為非終止，如果是true的話，初始狀態則為終止。然後建立並啟動一個子執行緒，在子執行緒中，通過呼叫AutoResetEvent的WaitOne方法，使子執行緒等待指定事件的發生。然後主執行緒等待一秒後，呼叫AutoResetEvent的Ｓｅｔ方法，使狀態由非終止變為終止，重新啟用子執行緒。
 

參考：
 

1/MSDN(http://msdn.microsoft.com/zh-cn/library/ms173179(VS.80).aspx )
 

2/http://www.cnblogs.com/VincentWP/archive/2008/06/25/1229104.html
 

https://www.cnblogs.com/michaelxu/archive/2008/09/20/1293716.html
   
 
 
 
 

            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
歸納一下:C#執行緒同步的幾種方法

     
 　我們在程式設計的時候，有時會使用多執行緒來解決問題，比如你的程式需要在後臺處理一大堆資料，但還要使使用者介面處於可操作狀態；或者你的程式需要訪問一些外部資源如資料庫或網路檔案等。這些情況你都可以建立一個子執行緒去處理，然而，多執行緒不可避免地會帶來一個問題，就是執行緒同步的問題。如果這個問題處理不好，我們就 



  
 

    


    
    
4. 執行緒同步幾種方式

     
 

執行緒同步的方式主要有以下四種:臨界區（Critical Section）、互斥量（Mutex）、訊號量（Semaphore）、事件（Event）的區別。

他們的主要區別和特點如下：

1）臨界區：通過對多執行緒的序列化來訪問公共資源或一段程式碼，速度快，適合控制資料訪問。在任意時刻只允許一個執行緒對共 



  
 

    


    
    
iOS 執行緒同步幾種方式

     
 
							
							
							多執行緒同步目的有以下幾個方面：第一，對一段程式碼的執行進行保護，如果同時執行一段程式碼，中間的臨時變數可能會互相干擾造成結果不對；第二，對資源的保護，多個執行緒執行不同的程式碼，但是可能涉及同一個資源；第三，訊息傳遞，一個執行緒通知另外一個執行緒發生了一件事。 



  
 

    


    
    
C++執行緒的幾種呼叫方式

     
 
								
								            
						
                
#include<thread>
#include<future>
using namespace std;

class A
{
public:
	void f(int x, 



  
 

    


    
    
多執行緒(一)：建立執行緒的幾種方法

     
  
 
 概括來說就是兩種：1、繼承Thread類，重寫run方法，然後start。不推薦這種，因為java的單繼承特性。
 
 2、Thread類的建構函式中可以接受Runnable任務，所以只要是Runnable例項就可以作為引數給Thread
 一般有兩種建立Runnable例項的方法（1）實現Runn 



  
 

    


    
    
Java 多執行緒 學習筆記（二）停止執行緒的幾種方法

     
 
								
								            
						
                
1.異常法：

package test;

import exthread.MyThread;

import exthread.MyThread;

public class Run {

	pu 



  
 

    


    
    
Java停止一個執行緒的幾種方法

     
 
                
Java中停止一個執行緒有三種方法，分別是stop,interrupt和設定標誌位，我們依次來看一下這三種方法。
首先不推薦使用stop方法，原因有兩點：
1、原則上只要一呼叫thread.stop()方法，執行緒就會立即停止，並丟擲ThreadDeath error，查看 



  
 

    


    
    
建立多執行緒的幾種方法

     
 
                

多執行緒有幾種實現方法，分別是什麼？（建立執行緒的幾種方式）


多執行緒有三種實現方法：

1、繼承Thread類，重寫run（）方法。然後直接new這個物件的例項，建立一個執行緒的例項，再呼叫start（）方法啟動執行緒。（其實本質上Thread是實現了Runnabl 



  
 

    


    
    
java多執行緒之使用interrupt停止執行緒的幾種方法

     
 
							
							
							停止執行緒

停止執行緒是java多執行緒開發中很重要的技術點，實際工作中很多業務都有類似的需求，掌握此技術可以對業務中所需停止的執行緒做有效的處理。但是停止執行緒在java語言中並不像break語句中那樣乾脆簡單，還需要我們做一下技巧性的處理。 
如何更好的停 



  
 

    


    
    
建立多執行緒有幾種方法？如何建立執行緒？

     
 
                
多執行緒有幾種實現方法？
多執行緒實現又3種方法，其中前兩中是常用的方法，推薦第二種方法，一個類應該在其修改或者加強是才繼承
1.繼承Thread類，重寫run()方法，例項化該類，呼叫執行緒start()方法

(1)自定義類，繼承Thread類，重寫run()方法
(2 



  
 

    


    
    
Python併發程式設計之建立多執行緒的幾種方法

     
 
                今天的內容會比較基礎，主要是為了讓新手也能無障礙地閱讀，所以還是要再鞏固下基礎。學完了基礎，你們也就能很順暢地跟著我的思路理解以後的文章。本文目錄學會使用函式建立多執行緒學會使用類建立多執行緒多執行緒：必學函式講解經過總結，Python建立多執行緒主要有如下兩種方法：函式類接 



  
 

    


    
    
Android將任務拋到UI執行緒的幾種方法

     
 
                

有的時候，我們希望能將任務拋回到UI執行緒去做，比如修改介面。如果當前沒有處在UI執行緒，那應該怎麼把任務拋到UI執行緒去呢？


以下是Android系統提供的3個將任務拋回UI執行緒的方法
Activity.runOnUiThread(Runnable)View.po 



  
 

    


    
    
java多執行緒同步5種方法

     
 
                一、引言前幾天面試，被大師虐殘了，好多基礎知識必須得重新拿起來啊。閒話不多說，進入正題。二、為什麼要執行緒同步因為當我們有多個執行緒要同時訪問一個變數或物件時，如果這些執行緒中既有讀又有寫操作時，就會導致變數值或物件的狀態出現混亂，從而導致程式異常。舉個例子，如果一個銀行賬戶 



  
 

    


    
    
建立執行緒的幾種方法及比較

     
 
                


1、通過繼承Thread類建立執行緒

(1).首先定義一個類去繼承Thread父類，重寫父類中的run()方法。在run()方法中加入具體的任務程式碼或處理邏輯。(2).直接建立一個ThreadTest類的物件，也可以利用多型性，變數宣告為父類的型別。

(3).呼叫 



  
 

    


    
    
C#執行緒同步的幾種方法

     
 Code public void Function() {object lockThis = new object (); lock (lockThis){// Access thread-sensitive resources. }} 

         



  
 

    


    
    
C++執行緒同步的四種方式（Windows）

     
 
							
							
							為什麼要進行執行緒同步？

　　在程式中使用多執行緒時，一般很少有多個執行緒能在其生命期內進行完全獨立的操作。更多的情況是一些執行緒進行某些處理操作，而其他的執行緒必須對其處理結果進行了解。正常情況下對這種處理結果的瞭解應當在其處理任務完成後進行。 
　　如果不 



  
 

    


    
    
多執行緒有幾種實現方法?同步有幾種實現方法?

     
 
                

為何要使用同步？

java允許多執行緒併發控制，當多個執行緒同時操作一個可共享的資源變數時（如資料的增刪改查）， 
將會導致資料不準確，相互之間產生衝突，因此加入同步鎖以避免在該執行緒沒有完成操作之前，被其他執行緒的呼叫， 
從而保證了該變數的唯一性和準確性。

同步的 



  
 

    


    
    
Java中建立執行緒的幾種方式以及執行緒同步的幾種方式

     
 
							
							
							執行緒同步自己及基本就用過Thread和Runnable這兩種方式，還有其他很多方式如下： 
Executor框架簡介 
建立執行緒有幾種不同的方式？你喜歡哪一種？為什麼？ 
而執行緒同步會用的方式就更少了，只會synchronized，其他方式如下： 
關於執 



  
 

    


    
    
c#使用多執行緒的幾種方式示例詳解

     
 
                
(1)不需要傳遞引數,也不需要返回引數
ThreadStart是一個委託，這個委託的定義為void ThreadStart()，沒有引數與返回值。
複製程式碼程式碼如下:

class Program


{

static void Main(string[] args) 



  
 

    


    
    
設計模式之單例模式【內附物件例項化幾種方式、實現執行緒安全幾種方式】

     
  
 
 繼續來複習常用的設計模式-單例模式，順便回憶一下執行緒安全的幾種實現方式。 
 一、什麼是單例模式 
 單例模式，簡單常用的一種設計模式，也很好的體現了程式碼控制物件在記憶體數量的一種方式，主要分2種實現方式： 
 ①餓漢式，執行緒安全 
 ②懶漢式，執行緒不安全（新增鎖機制，可以實現執行緒安全）