C# 锁定问题-多个线程使循环失去顺序

我有一个示例应用程序，不知道是否有人可以对此进行说明。当我在调试程序中代码的步骤的循环上放置断点时，为什么它会从一个线程切换到另一个线程？它在运行时运行应用程序时执行此操作…请参阅下面的代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TPLSample
{
    class Program
    {

        static void Main(string[] args)
        {
           Management m = new Management();

           Task a = new Task(() => m.Operation1());
           a.Start();
           Task b = new Task(() => m.Operation2());
           b.Start();


            Console.ReadLine();
        }
    }
    public class Management
    {
        A a = null;
        B b = null;

        public void Operation1()
        {
            a = new A();

        }
        public void Operation2()
        {
            b = new B();
        }
    }
    public class A
    {  Client a = new Client();
        public A()
        {
            while (true)
            {
                a.Test("Im AAAAA");
            }
        }
    }
    public class B
    {
        Client a = new Client();
        public B()
        {
            while (true)
            {
                a.Test("Im BBBBB");
            }
        }
    }
    public class Client
    {
        Object ibj = new Object();


        public void Test(string item)
        {
            lock (ibj)
            {
                for (int i = 0; i < 200000; i++)
                {
                    Console.WriteLine(item);
                }
            }

        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
命名空间TPLSample
{
班级计划
{
静态void Main（字符串[]参数）
{
管理m=新管理（）；
任务a=新任务（（）=>m.Operation1（））；
a、 Start（）；
任务b=新任务（（）=>m.Operation2（））；
b、 Start（）；
Console.ReadLine（）；
}
}
公共班级管理
{
A=零；
B=零；
公开无效操作1（）
{
a=新的a（）；
}
公开无效操作2（）
{
b=新的b（）；
}
}
公共A类
{客户机a=新客户机（）；
公共A（）
{
while（true）
{
a、 测试（“Im AAAA”）；
}
}
}
公共B级
{
客户机a=新客户机（）；
公共图书馆B（）
{
while（true）
{
a、 测试（“Im BBB”）；
}
}
}
公共类客户端
{
Object ibj=新对象（）；
公共无效测试（字符串项）
{
锁（ibj）
{
对于（int i=0；i<200000；i++）
{
控制台写入线（项目）；
}
}
}
}
}

---

其结果是As和Bs的混合物。锁不应该阻塞线程，这样结果就会按顺序结束吗？我正在编写的应用程序中也发生了同样的情况，只是WHILE循环永远运行（每个任务都需要持续轮询）。请注意，我开始两个任务，因为如果WHILE循环要永远运行，我不希望一个WHILE循环阻止另一个运行。如何使它们按顺序进入客户机类中的该函数？

这是因为如果仔细跟踪对象创建树，您会注意到每个线程使用不同的锁对象，从而使您的

lock

语句无效

对象创建过程如下所示：

                 new A() -> new Client() -> new Object()
                / 
new Management()
                \
                 new B() -> new Client() -> new Object()

将右侧的最后两个对象用作锁，可以清楚地看到它们是不同的对象

尝试将锁设为静态：

public class Client
{
    static Object ibj = new Object();
    ...

---

或者重新考虑您的层次结构，将相同的锁传递给两个任务。

每个对象必须具有对相同对象的访问权限才能使锁工作。您可以通过使ibj对象成为静态的，或者将其传递到客户机类中来实现这一点

public class Client
{
    static Object ibj = new Object();


    public void Test(string item)
    {
        lock (ibj)
        {
            for (int i = 0; i < 200000; i++)
            {
                Console.WriteLine(item);
            }
        }

    }
}

公共类客户端
{
静态对象ibj=新对象（）；
公共无效测试（字符串项）
{
锁（ibj）
{
对于（int i=0；i<200000；i++）
{
控制台写入线（项目）；
}
}
}
}

每个对象都有自己的锁。如果他们试图获取相同的锁，那么结果将被序列化，这在我编写的另一个应用程序中也有帮助。感谢您的帮助+1：很好地使用了“\”和“/”字符。我可能也不得不窃取这个想法来寻找答案：）