如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。
或者說:一個類或者程序所提供的接口對於線程來說是原子操作或者多個線程之間的切換不會導致該接口的執行結果存在二義性,也就是說我們不用考慮同步的問題。
線程安全問題都是由全局變量及靜態變量引起的。
若每個線程中對全局變量、靜態變量只有讀操作，而無寫操作，一般來說，這個全局變量是線程安全的；若有多個線程同時對一個變量執行讀寫操作，一般都需要考慮線程同步，否則就可能影響線程安全。
lock的目的是防止多線程執行的時候出現並發操作問題，加上lock的引用類型的對象，在其鎖定的區域內，在一個時刻只允許一個線程操作。
lock只能鎖定一個引用類型變量，也就是鎖定一個地址
class Program
{
static void Main(string[] args)
{
threda t=new threda();
threda.obj.i = 10;
Thread th1 = new Thread(new ThreadStart(t.hhh));
th1.Name = "th1";
th1.Start();
Thread th2 = new Thread(new ThreadStart(t.hhh));
th2.Name = "th2";
th2.Start();
}
}
class threda
{
public static sss obj = new sss();
public void hhh()
{
lock (obj)
{
for (int i = 0; i < 7; i++)
{
Thread.Sleep(500);
if (obj.i >0)
{
obj.i--;
Console.WriteLine("當前線程名："+Thread.CurrentThread.Name+"， obj.i= " + obj.i);
}
}
}
}
}
class sss
{
public int i ;
}
加鎖和不加鎖運行的結果有區別 ：
加鎖後：i的值會一個個遞減，不會出現跳躍，不會出現重復輸出，一直到0值；
不加鎖：i的值輸出會出現跳躍，不連續遞減，可能還會出現-1值輸出；
原因：加鎖後，一個時刻只能有一個線程執行被鎖區域的代碼，兩個線程都是有先後順序執行的，所以不會出現間斷輸出。
一. 為什麼要lock，lock了什麼？
當我們使用線程的時候，效率最高的方式當然是異步，即各個線程同時運行，其間不相互依賴和等待。但當不同的線程都需要訪問某個資源的時候，就需要同步機制了，也就是說當對同一個資源進行讀寫的時候，我們要使該資源在同一時刻只能被一個線程操作，以確保每個操作都是有效即時的，也即保證其操作的原子性。lock是C#中最常用的同步方式，格式為lock(objectA){codeB} 。
lock(objectA){codeB} 看似簡單，實際上有三個意思，這對於適當地使用它至關重要：
1. objectA被lock了嗎？沒有則由我來lock，否則一直等待，直至objectA被釋放。
2. lock以後在執行codeB的期間其他線程不能調用codeB，也不能使用objectA。
3. 執行完codeB之後釋放objectA，並且codeB可以被其他線程訪問。
二. lock(this)怎麼了？
我們看一個例子：
using System;
using System.Threading;
namespace Namespace1
{
class C1
{
private bool deadlocked = true;
//這個方法用到了lock，我們希望lock的代碼在同一時刻只能由一個線程訪問
public void LockMe(object o)
{
lock (this)
{
while(deadlocked)
{
deadlocked = (bool)o;
Console.WriteLine("Foo: I am locked :(");
Thread.Sleep(500);
}
}
}
//所有線程都可以同時訪問的方法
public void DoNotLockMe()
{
Console.WriteLine("I am not locked :)");
}
}
class Program
{
static void Main(string[] args)
{
C1 c1 = new C1();
//在t1線程中調用LockMe，並將deadlock設為true（將出現死鎖）
Thread t1 = new Thread(c1.LockMe);
t1.Start(true);
Thread.Sleep(100);
//在主線程中lock c1
lock (c1)
{
//調用沒有被lock的方法
c1.DoNotLockMe();
//調用被lock的方法，並試圖將deadlock解除
c1.LockMe(false);
}
}
}
復制代碼
在t1線程中，LockMe調用了lock(this), 也就是Main函數中的c1，這時候在主線程中調用lock(c1)時，必須要等待t1中的lock塊執行完畢之後才能訪問c1，即所有c1相關的操作都無法完成，於是我們看到連c1.DoNotLockMe()都沒有執行。
把C1的代碼稍作改動：
class C1
{
private bool deadlocked = true;
private object locker = new object();
//這個方法用到了lock，我們希望lock的代碼在同一時刻只能由一個線程訪問
public void LockMe(object o)
{
lock (locker)
{
while(deadlocked)
{
deadlocked = (bool)o;
Console.WriteLine("Foo: I am locked :(");
Thread.Sleep(500);
}
}
}
//所有線程都可以同時訪問的方法
public void DoNotLockMe()
{
Console.WriteLine("I am not locked :)");
}
}
復制代碼
這次我們使用一個私有成員作為鎖定變量(locker)，在LockMe中僅僅鎖定這個私有locker，而不是整個對象。這時候重新運行程序，可以看到雖然t1出現了死鎖，DoNotLockMe()仍然可以由主線程訪問；LockMe()依然不能訪問，原因是其中鎖定的locker還沒有被t1釋放。
關鍵點：
1. lock(this)的缺點就是在一個線程（例如本例的t1）通過執行該類的某個使用"lock(this)"的方法(例如本例的LockMe())鎖定某對象之後, 導致整個對象無法被其他線程(例如本例的主線程)訪問 - 因為很多人在其他線程(例如本例的主線程)中使用該類的時候會使用類似lock(c1)的代碼。
2. 鎖定的不僅僅是lock段裡的代碼，鎖本身也是線程安全的。
3. 我們應該使用不影響其他操作的私有對象作為locker。
4. 在使用lock的時候，被lock的對象(locker)一定要是引用類型的，如果是值類型，將導致每次lock的時候都會將該對象裝箱為一個新的引用對象(事實上如果使用值類型，C#編譯器(3.5.30729.1)在編譯時就會給出一個錯誤)。
