僵局澄清？

也许对“死锁”还有其他解释，但据我所知：

当发生死锁时两个线程各自等待一个资源 另一个，所以两者都无法继续。

但我在这里看到了几个答案，它们声称长时间的等待（不互相等待）也是一个僵局：

例子#1 https://stackoverflow.com/a/894071/859154

namespace ConsoleApplication7
{
    public class Program
    {
        public static void Main(string[] args)
        {
            LockableClass lockable = new LockableClass();
            new Thread(new ParameterizedThreadStart(BackgroundMethod)).Start(lockable);
            Thread.Sleep(500);
            Console.Out.WriteLine("calling Reset");
            lockable.Reset();
        }

        private static void BackgroundMethod(Object lockable)
        {
            lock (lockable)
            {
                Console.Out.WriteLine("background thread got lock now");
                Thread.Sleep(Timeout.Infinite);
            }
        }
    }

    public class LockableClass
    {
        public Int32 Value1 { get; set; }
        public Int32 Value2 { get; set; }

        public void Reset()
        {
            Console.Out.WriteLine("attempting to lock on object");
            lock (this)
            {
                Console.Out.WriteLine("main thread got lock now");
                Value1 = 0;
                Value2 = 0;
            }
        }
    }

}

请原谅，我在这里看到的只是一个尚未释放的纯粹的锁。 这不是两个线程都在等待另一个线程的情况。线程 这里does NOT等待主线程完成。

另一个例子#2 https://stackoverflow.com/a/728920/859154

class ILockMySelf
{
    void doThat()
    {
        lock(this){ ... }
    }
}

class WeveGotAProblem
{
    ILockMySelf anObjectIShouldntUseToLock;

    void doThis()
    {
        lock(anObjectIShouldntUseToLock)
        {
            // Following line should run in a separate thread
            // for the deadlock to happen
            anObjectIShouldntUseToLock.doThat();
        }
    }
}

同样在这里。运行的线程doThis不等待将运行的“单独线程”doThat

问题 ：

• 这里涉及死锁吗？

我同意 David Hope 的观点，死锁的定义很广泛，适用于线程之外的场景。但是，第二个示例不是死锁，因为它不存在导致线程“停止”的情况。

要纠正第二个示例，请启动一个新线程and强制线程 1 等待线程 2。然后，你可以创建一个死锁：

//Deadlock
public class Program
{
    public static void Main(string[] args)
    {
        WeveGotAProblem p = new WeveGotAProblem();
        p.doThis();//gain a lock on this thread                        
    }        
}

class ILockMySelf
{
    public void doThat()
    {
        //Thread2 waits on Thread1 to release "this"
        lock (this)
        {
            Console.WriteLine("that");
        }
    }
}

class WeveGotAProblem
{
    ILockMySelf anObjectIShouldntUseToLock = new ILockMySelf();

    public void doThis()
    {
        lock (anObjectIShouldntUseToLock)
        {
            Task task = Task.Factory.StartNew(new Action(() => anObjectIShouldntUseToLock.doThat()));
            Task.WaitAll(task);//Thread1 waits on Thread2 to return.  This is important
        }
    }
}

这里我们有两个或多个相互竞争的动作，每个动作都等待对方完成。

• 线程 1 正在等待线程 2 返回。
• 线程 2 正在等待线程 1 释放其所需的资源，然后才能返回。

第一个示例（尽管是人为的......为什么让线程永远休眠......？）可能会因类似的原因导致死锁。

E.G.

• Thread1 等待 Thread.Sleep() 返回（它永远不会）
• 线程2等待线程1释放lockable上的锁（它永远不会）

事实上，动作是线程，每个线程都在等待不同的结果，这只是实现细节。