多線程編程之常見錯誤實踐和優(yōu)秀實踐
在多線程編程中，由于存在共享資源和競爭條件等問題，容易出現(xiàn)各種錯誤。以下是一些常見的多線程編程錯誤及如何避免它們：
競態(tài)條件（Race Condition）：在多個線程同時訪問共享資源時，可能會發(fā)生數(shù)據(jù)競爭，導(dǎo)致程序錯誤。為了避免競態(tài)條件，可以使用同步機(jī)制，例如互斥鎖、信號量、條件變量等，確保同一時刻只有一個線程訪問共享資源。
錯誤實踐代碼：
int count = 0;
// 創(chuàng)建 10 個線程對共享變量進(jìn)行累加操作
for (int i = 0; i < 10; i++)
{
new Thread(() =>
{
for (int j = 0; j < 1000; j++)
{
count++;
}
}).Start();
}
// 等待所有線程執(zhí)行完成后輸出累加結(jié)果
Thread.Sleep(1000);
Console.WriteLine("count = " + count);上述代碼會啟動 10 個線程對共享的變量 count 進(jìn)行累加操作。由于 count 變量是共享的，多個線程可能會同時訪問 count，導(dǎo)致數(shù)據(jù)競爭，從而導(dǎo)致程序錯誤。
最佳實踐代碼：
int count = 0;
object lockObj = new object();
// 創(chuàng)建 10 個線程對共享變量進(jìn)行累加操作
for (int i = 0; i < 10; i++)
{
new Thread(() =>
{
for (int j = 0; j < 1000; j++)
{
lock(lockObj)
count++;
}
}).Start();
}
// 等待所有線程執(zhí)行完成后輸出累加結(jié)果
Thread.Sleep(1000);
Console.WriteLine("count = " + count);在最佳實踐示例代碼中，使用了互斥鎖來保護(hù)共享變量 count 的訪問，確保同一時刻只有一個線程對 count 進(jìn)行操作。
死鎖（Deadlock）：當(dāng)多個線程同時等待對方釋放資源時，可能會出現(xiàn)死鎖情況，導(dǎo)致程序無法繼續(xù)執(zhí)行。為了避免死鎖，需要合理地設(shè)計同步流程，避免出現(xiàn)環(huán)路等結(jié)構(gòu)。
錯誤實踐代碼：
object lockObj1 = new object();
object lockObj2 = new object();
// 線程 1
new Thread(() =>
{
lock(lockObj1)
{
Console.WriteLine("thread1 acquired lock1");
Thread.Sleep(1000);
lock (lockObj2)
{
Console.WriteLine("thread1 acquired lock2");
}
}
}).Start();
// 線程 2
new Thread(() =>
{
lock (lockObj2)
{
Console.WriteLine("thread2 acquired lock2");
Thread.Sleep(1000);
lock (lockObj1)
{
Console.WriteLine("thread2 acquired lock1");
}
}
}).Start();上述代碼中，兩個線程分別占用不同的鎖 lockObj1 和 lockObj2，并且在使用完一個鎖之后嘗試獲取另一個鎖，從而可能導(dǎo)致死鎖的問題。
最佳實踐代碼：
object lockObj1 = new object();
object lockObj2 = new object();
// 線程 1
new Thread(() =>
{
lock(lockObj1)
{
Console.WriteLine("thread1 acquired lock1");
Thread.Sleep(1000);
lock (lockObj2)
{
Console.WriteLine("thread1 acquired lock2");
}
}
}).Start();
// 線程 2
new Thread(() =>
{
lock (lockObj1)
{
Console.WriteLine("thread2 acquired lock1");
Thread.Sleep(1000);
lock (lockObj2)
{
Console.WriteLine("thread2 acquired lock2");
}
}
}).Start();在最佳實踐示例代碼中，將兩個線程獲取鎖的順序統(tǒng)一為 lockObj1 -> lockObj2，從而避免死鎖問題。
過度的鎖競爭（Lock Contention）：當(dāng)多個線程在高頻率地訪問同一個鎖時，可能會導(dǎo)致過度的鎖競爭，降低程序的并發(fā)性能。為了避免過度的鎖競爭，可以使用非阻塞算法、讀寫鎖等替代互斥鎖；也可以嘗試減小鎖粒度，將鎖的范圍縮小到最小。
錯誤實踐代碼：
object lockObj = new object();
List<int> list = new List<int>();
Random random = new Random();
// 創(chuàng)建 10 個線程對共享集合進(jìn)行操作，使用互斥鎖保護(hù) list 的并發(fā)訪問
for (int i = 0; i < 10; i++)
{
new Thread(() =>
{
for (int j = 0; j < 10000; j++)
{
lock(lockObj)
{
// 使用隨機(jī)數(shù)生成一個新的元素并添加到集合中
int randNum = random.Next(100);
list.Add(randNum);
}
}
}).Start();
}
// 等待所有線程執(zhí)行完成后輸出集合元素個數(shù)
Thread.Sleep(1000);
Console.WriteLine("list count = " + list.Count);在上述代碼中，由于使用了互斥鎖保護(hù)集合的并發(fā)訪問，每個線程在對集合進(jìn)行操作時都需要獲取鎖，從而可能導(dǎo)致過度的鎖競爭，導(dǎo)致程序性能下降。
最佳實踐代碼：
ConcurrentBag<int> bag = new ConcurrentBag<int>();
Random random = new Random();
// 創(chuàng)建 10 個線程對共享集合進(jìn)行操作，使用并發(fā)容器代替互斥鎖進(jìn)行線程安全的并發(fā)訪問
for (int i = 0; i < 10; i++)
{
new Thread(() =>
{
for (int j = 0; j < 10000; j++)
{
// 使用隨機(jī)數(shù)生成一個新的元素并添加到集合中
int randNum = random.Next(100);
bag.Add(randNum);
}
}).Start();
}
// 等待所有線程執(zhí)行完成后輸出集合元素個數(shù)
Thread.Sleep(1000);
Console.WriteLine("list count = " + bag.Count);在最佳實踐示例代碼中，使用了線程安全的并發(fā)容器 ConcurrentBag 代替了互斥鎖，確保了集合的線程安全，同時避免了過度的鎖競爭問題。
上下文切換（Context Switching）：當(dāng)多個線程在不斷地切換執(zhí)行時，可能會引起上下文切換的開銷增加，從而導(dǎo)致程序性能下降。為了避免上下文切換，可以使用線程池等技術(shù)，減少線程的創(chuàng)建和銷毀操作。
錯誤實踐代碼：
List<int> list = new List<int>();
// 創(chuàng)建 100 個線程對共享集合進(jìn)行操作
for(int i = 0;i < 100;i++)
{
new Thread(() =>
{
for(int j = 0;j < 100000;j++)
{
// 在集合中添加一個元素
list.Add(1);
}
}).Start();
}
// 等待所有線程執(zhí)行完成后輸出集合元素個數(shù)
Thread.Sleep(5000);
Console.WriteLine("list count = " + list.Count);在上述代碼中，由于同時啟動了大量的線程，在并發(fā)執(zhí)行時會不斷地進(jìn)行上下文切換，導(dǎo)致程序性能下降
最佳實踐代碼：
const int threadCount = 10;
List<int> list = new List<int>();
// 使用線程池創(chuàng)建多個線程，避免頻繁的線程創(chuàng)建和銷毀操作
for(int i = 0;i < threadCount;i++)
{
ThreadPool.QueueUserWorkItem((state) =>
{
for(int j = 0;j < 100000;j++)
{
// 在集合中添加一個元素
lock(list)
list.Add(1);
}
});
}
// 等待所有線程執(zhí)行完成后輸出集合元素個數(shù)
while(Thread.VolatileRead(ref threadCount) > 0)
{
Thread.Sleep(100);
}
Console.WriteLine("list count = " + list.Count);在最佳實踐示例代碼中，使用線程池代替了手動創(chuàng)建線程的方式，避免了頻繁的線程創(chuàng)建和銷毀操作，從而減少了上下文切換的開銷。此外，在訪問共享變量 list 時，使用了互斥鎖來確保線程安全。
內(nèi)存泄漏（Memory Leak）：在多線程編程中，由于對資源的釋放不當(dāng)，可能會引發(fā)內(nèi)存泄漏問題。為了避免內(nèi)存泄漏，需要正確地使用內(nèi)存管理機(jī)制，并保證資源在使用完畢后及時釋放。
錯誤實踐代碼：
class ResourceHolder
{
private byte[] buffer = new byte[1024 * 1024 * 10];
// 析構(gòu)函數(shù)
~ResourceHolder()
{
Console.WriteLine("ResourceHolder finalized.");
}
}
// 創(chuàng)建 100 個線程，每個線程都會創(chuàng)建一個 ResourceHolder 對象并存儲在集合中
List<ResourceHolder> holders = new List<ResourceHolder>();
for(int i = 0;i < 100;i++)
{
new Thread(() =>
{
holders.Add(new ResourceHolder());
}).Start();
}
// 等待所有線程執(zhí)行完成后等待一段時間，觸發(fā) GC 進(jìn)行垃圾回收
Thread.Sleep(5000);
GC.Collect();
Console.WriteLine("Done.");在上述代碼中，由于創(chuàng)建了大量的 ResourceHolder 對象，并將其存儲在集合中，但是沒有及時釋放這些對象，從而可能導(dǎo)致內(nèi)存泄漏的問題。
最佳實踐代碼：
class ResourceHolder : IDisposable
{
private byte[] buffer = new byte[1024 * 1024 * 10];
// 實現(xiàn) IDisposable 接口
public void Dispose()
{
Console.WriteLine("ResourceHolder disposed.");
}
}
// 創(chuàng)建 100 個線程，每個線程都會創(chuàng)建一個 ResourceHolder 對象并存儲在集合中
List<ResourceHolder> holders = new List<ResourceHolder>();
for(int i = 0;i < 100;i++)
{
new Thread(() =>
{
// 使用 using 語句塊確保及時釋放資源
using(ResourceHolder holder = new ResourceHolder())
{
holders.Add(holder);
}
}).Start();
}
// 等待所有線程執(zhí)行完成后輸出 Done
Thread.Sleep(5000);
Console.WriteLine("Done.");在最佳實踐示例代碼中，使用了 IDisposable 接口和 using 語句塊來確保及時釋放資源，避免了內(nèi)存泄漏問題。
除此之外，還有一些其他的多線程編程錯誤，例如訪問未初始化的共享資源、線程間通信不當(dāng)、異常處理不當(dāng)?shù)?。為了避免這些錯誤，需要在編碼過程中嚴(yán)格遵循多線程編程的最佳實踐，例如使用安全的并發(fā)容器、避免鎖策略過度簡單、避免線程死循環(huán)等。同時，在編碼過程中仔細(xì)閱讀相關(guān)文檔和資料，了解當(dāng)前使用的庫或框架的特性和限制，以確保代碼的正確性和健壯性。
