Koleksi serentak dan isu keselamatan benang dalam C#

Pengumpulan serentak biasa dan isu keselamatan benang dalam C#

Dalam pengaturcaraan C#, pengendalian operasi serentak adalah keperluan yang sangat biasa. Isu keselamatan benang timbul apabila berbilang benang mengakses dan mengubah suai data yang sama pada masa yang sama. Untuk menyelesaikan masalah ini, C# menyediakan beberapa pengumpulan serentak dan mekanisme keselamatan benang. Artikel ini akan memperkenalkan koleksi serentak biasa dalam C# dan cara menangani isu keselamatan benang, dan memberikan contoh kod khusus.

1. Concurrent Collection

1.1 ConcurrentDictionary

ConcurrentDictionary ialah koleksi kamus serentak yang biasa digunakan dalam C#, yang membolehkan berbilang benang membaca dan menulis pasangan nilai kunci yang berbeza pada masa yang sama, dan menyediakan mekanisme untuk mengendalikan penyegerakan benang secara automatik . Berikut ialah contoh penggunaan ConcurrentDictionary:

ConcurrentDictionary<string, int> concurrentDict = new ConcurrentDictionary<string, int>();

// 添加键值对
concurrentDict.TryAdd("key1", 1);
concurrentDict.TryAdd("key2", 2);

// 更新值
concurrentDict.TryUpdate("key1", 3, 1);

// 删除键值对
int value;
concurrentDict.TryRemove("key2", out value);

1.2 ConcurrentQueue

ConcurrentQueue ialah koleksi baris gilir selamat benang dalam C# yang membolehkan berbilang benang menambah elemen pada penghujung baris gilir dan mendapatkan serta memadam elemen pada kepala baris gilir di masa yang sama. Berikut ialah contoh menggunakan ConcurrentQueue:

ConcurrentQueue<int> concurrentQueue = new ConcurrentQueue<int>();

// 入队
concurrentQueue.Enqueue(1);
concurrentQueue.Enqueue(2);

// 出队
int result;
if(concurrentQueue.TryDequeue(out result))
{
    // 处理出队的元素
}

1.3 ConcurrentBag

ConcurrentBag ialah koleksi tidak tertib selamat benang dalam C# yang membenarkan berbilang benang menambah dan mengalih keluar elemen secara serentak. Berikut ialah contoh penggunaan ConcurrentBag:

ConcurrentBag<int> concurrentBag = new ConcurrentBag<int>();

// 添加元素
concurrentBag.Add(1);
concurrentBag.Add(2);

// 移除元素
int result;
if(concurrentBag.TryTake(out result))
{
    // 处理移除的元素
}

2. Isu keselamatan benang

2.1 Keadaan perlumbaan

Keadaan perlumbaan merujuk kepada ketidakpastian keputusan yang disebabkan oleh urutan akses kepada sumber dikongsi oleh berbilang rangkaian. Untuk menyelesaikan keadaan perlumbaan, mekanisme penguncian (kunci) boleh digunakan untuk memastikan pengecualian bersama akses berbilang benang kepada sumber yang dikongsi. Berikut ialah contoh penggunaan kunci untuk menyelesaikan keadaan perlumbaan:

class Counter
{
    private int count;

    public void Increment()
    {
        lock (this)
        {
            count++;
        }
    }

    public int GetCount()
    {
        lock (this)
        {
            return count;
        }
    }
}

2.2 Jalan buntu

Kebuntuan merujuk kepada situasi di mana berbilang benang sedang menunggu antara satu sama lain untuk melepaskan sumber, menyebabkan program tidak dapat meneruskan pelaksanaan. Untuk mengelakkan kebuntuan, anda boleh memperoleh kunci dalam susunan yang sama, atau gunakan pernyataan cuba-akhir untuk memastikan keluaran biasa sumber. Berikut ialah contoh kebuntuan mudah:

class Deadlock
{
    private static object lock1 = new object();
    private static object lock2 = new object();

    static void Main(string[] args)
    {
        Thread thread1 = new Thread(() => {
            lock (lock1)
            {
                Thread.Sleep(1000); // 为了让另一个线程有机会获取lock2
                lock (lock2)
                {
                    // do something
                }
            }
        });

        Thread thread2 = new Thread(() => {
            lock (lock2)
            {
                Thread.Sleep(1000); // 为了让另一个线程有机会获取lock1
                lock (lock1)
                {
                    // do something
                }
            }
        });

        thread1.Start();
        thread2.Start();
    }
}

Di atas ialah pengenalan kepada koleksi serentak dan isu keselamatan benang dalam C#, serta contoh kod khusus. Apabila melakukan pengaturcaraan serentak, kita perlu memahami mekanisme dan isu ini dan memilih penyelesaian yang sesuai untuk memastikan keselamatan benang. Dengan menggunakan koleksi serentak dengan betul dan mengelakkan isu keselamatan benang, kami boleh meningkatkan prestasi dan kebolehpercayaan program kami.

Atas ialah kandungan terperinci Koleksi serentak dan isu keselamatan benang dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!