Masalah penyegerakan benang biasa dan penyelesaian dalam C#

Masalah dan penyelesaian penyegerakan benang biasa dalam C#

Pengenalan:
Dalam pengaturcaraan berbilang benang, penyegerakan benang ialah konsep utama. Apabila berbilang rangkaian mengakses sumber kongsi pada masa yang sama, masalah seperti ketidakkonsistenan data atau keadaan perlumbaan mungkin berlaku. Artikel ini akan memperkenalkan masalah penyegerakan utas biasa dalam C# dan menyediakan penyelesaian yang sepadan serta kod sampel.

1. Perkongsian data yang salah
Apabila berbilang rangkaian mengakses sumber kongsi yang sama pada masa yang sama, ketidakkonsistenan data mungkin berlaku. Penyelesaian biasa untuk masalah ini ialah menggunakan mutex.

Kod sampel:

using System; using System.Threading; class Program { static int count = 0; static Mutex mutex = new Mutex(); static void Main() { Thread[] threads = new Thread[5]; for (int i = 0; i < 5; i++) { threads[i] = new Thread(Increment); threads[i].Start(); } foreach (Thread t in threads) { t.Join(); } Console.WriteLine("Count: " + count); } static void Increment() { mutex.WaitOne(); count++; mutex.ReleaseMutex(); } }

Dalam contoh di atas, kami mencipta kiraan pembolehubah global, dan kemudian mencipta 5 urutan untuk menambah kiraan. Menggunakan Mutex memastikan bahawa hanya satu utas boleh mengakses kiraan pada satu masa dan mengelakkan masalah ketidakkonsistenan data.

2. Keadaan perlumbaan
Keadaan perlumbaan berlaku apabila beberapa rangkaian cuba mengubah suai sumber yang dikongsi pada masa yang sama. Untuk mengelakkan keadaan perlumbaan, kami boleh menggunakan kelas Monitor atau pernyataan kunci untuk melindungi sumber yang dikongsi.

Kod sampel:

using System; using System.Threading; class Program { static int count = 0; static void Main() { Thread[] threads = new Thread[5]; for (int i = 0; i < 5; i++) { threads[i] = new Thread(Increment); threads[i].Start(); } foreach (Thread t in threads) { t.Join(); } Console.WriteLine("Count: " + count); } static void Increment() { lock (typeof(Program)) { count++; } } }

Dalam contoh di atas, kami menggunakan pernyataan kunci untuk melindungi kiraan. Pernyataan kunci memperoleh monitor secara automatik Apabila utas mengakses sumber yang dikongsi, utas lain disekat sehingga utas semasa melepaskan kunci.

3. Semaphore
Semaphore ialah alat penyegerakan yang digunakan untuk mengawal akses benang kepada sumber. Melalui semaphore, kami boleh mengehadkan bilangan akses serentak mengikut urutan untuk memastikan akses yang betul kepada sumber.

Kod sampel:

using System; using System.Threading; class Program { static int count = 0; static Semaphore semaphore = new Semaphore(2, 2); static void Main() { Thread[] threads = new Thread[5]; for (int i = 0; i < 5; i++) { threads[i] = new Thread(Increment); threads[i].Start(); } foreach (Thread t in threads) { t.Join(); } Console.WriteLine("Count: " + count); } static void Increment() { semaphore.WaitOne(); count++; semaphore.Release(); } }

Dalam contoh di atas, kami mencipta semaphore dengan nilai awal 2, menunjukkan bahawa 2 utas dibenarkan untuk mengakses sumber dikongsi pada masa yang sama. Apabila semua utas telah selesai dilaksanakan, kami mendapat nilai kiraan yang betul.

Kesimpulan:
Dengan mekanisme penyegerakan benang yang sesuai, kami boleh mengelakkan masalah biasa dalam pengaturcaraan berbilang benang C# dan memastikan berbilang benang boleh mengakses sumber kongsi dengan betul. Artikel ini memperkenalkan kod sampel menggunakan Mutex, pernyataan kunci dan Semaphore untuk rujukan pembaca. Apabila menulis aplikasi berbilang benang, anda perlu memilih kaedah penyegerakan yang sesuai berdasarkan keperluan sebenar untuk memastikan ketepatan dan prestasi program.

Atas ialah kandungan terperinci Masalah penyegerakan benang biasa dan penyelesaian dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!