c# 死锁和活锁的发生及避免

C# 死锁和活锁的发生及避免攻略

什么是死锁和活锁

死锁和活锁都是多线程并发编程中经常遇到的问题。

死锁

死锁指的是两个或更多的线程被永久地阻塞，无法继续执行，因为每个线程都在等待其他线程释放资源。简单来说，就是线程之间互相占用对方需要的资源，并不释放，而导致程序无限等待下去。

活锁

活锁指的是线程虽然没有被阻塞，但是他们却无法继续前进，因为它们总是在响应其他线程的任务而忙碌。例如，两个线程都试图通过让步来避免对方线程锁定，但是在这样做的过程中，双方都没有做任何有意义的工作，并最终无法完成其任务。

死锁和活锁的发生原因

死锁和活锁都是由于线程之间互相占用资源导致的。

死锁的发生原因

死锁通常发生在多个线程在访问相同的资源时，这些资源可能是共享的、独占的、控制台或者锁对象等。并且这些线程之间占用资源的顺序不同，导致一个线程在占用某个资源时，另一个线程也正在等待该资源，而另一个线程占用的资源则又被占用了，导致在无限等待下去的情况下，线程无法继续执行。

活锁的发生原因

活锁通常出现在多个线程试图通过让步来避免相互锁定的情况下，但是在多次让步后，线程总是重新试图获取资源而导致的。这种竞争的行为可能会导致线程在其他处理上浪费大量时间，并且这些线程可能永远无法完成其工作。

如何避免死锁和活锁的发生

为了避免死锁和活锁的发生，需要采取相应的措施：

死锁的避免

1.避免竞争

在多个线程同时需要在资源上进行操作时，为了避免死锁的发生，应该优先考虑以下几种方式：

• 降低并发性
• 统一资源分配和释放的顺序
• 使用超时

2.使用互斥锁

通常情况下，在对共享资源进行操作的时候，需要使用互斥锁来保护资源，提交完操作后，需要手动释放锁。

活锁的避免

1.避免相互让步

在多个线程相互竞争资源的情况下，应避免相互让步，否则会出现活锁的情况。

2.采用随机休眠

为了避免相互让步，可以采用随机休眠的方式，使线程在获取不到资源的情况下，随机休眠一段时间再进行重试。

示例说明

死锁示例

class Program
{
    static void Main(string[] args)
    {
        object lockA = new object();
        object lockB = new object();
        Thread t1 = new Thread(() =>
        {
            lock (lockA)
            {
                Thread.Sleep(1000);
                lock (lockB)
                {

                }
            }
        });
        Thread t2 = new Thread(() =>
        {
            lock (lockB)
            {
                Thread.Sleep(1000);
                lock (lockA)
                {

                }
            }
        });
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine("Main thread finished.");
    }
}

在上面的示例中，两个线程分别占用资源A和资源B，并在互相等待的情况下导致死锁的发生。为了避免死锁现象，应保证两个线程获取资源的顺序是一致的。

活锁示例

class Program
{
    static void Main(string[] args)
    {
        bool flag1 = true;
        bool flag2 = false;

        Thread t1 = new Thread(() =>
        {
            while (true)
            {
                if (flag1)
                {
                    Console.WriteLine("Thread 1 works.");
                    flag1 = false;
                    flag2 = true;
                }
                Thread.Sleep(1000);
            }
        });

        Thread t2 = new Thread(() =>
        {
            while (true)
            {
                if (flag2)
                {
                    Console.WriteLine("Thread 2 works.");
                    flag1 = true;
                    flag2 = false;
                }
                Thread.Sleep(1000);
            }
        });

        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine("Main thread finished.");
    }
}

在上面的示例中，两个线程t1和t2分别占用两个标志变量flag1和flag2，并交替将对方的标志变量设置为true和false。因为两个线程在相互让步的情况下，无法完成具体的工作，导致活锁现象的发生。为了避免这种现象，可以采用随机休眠的方式来打破互相让步的循环。