无法理解：使用lock()但从不执行代码

Question

我正在学习 C# 中的线程，我得到了我无法理解的行为。

该代码模拟 I/O 操作，例如文件或串行端口，其中一次只有一个线程可以访问它，并且它会阻塞直到完成。

启动了四个线程。每个只执行一次计数。它工作正常，我可以在表格上看到计数在增长。但有一个按钮可以从表单线程中计数。当我推动它时，主线程冻结。调试器显示其他线程一一继续计数，但表单线程永远无法访问该资源。

1）为什么当其他线程没有问题时，表单线程中的锁（tty）永远无法访问它？ 2）有没有更好的方法来进行这种类型的同步？

抱歉，代码太长了：

public class MegaAPI
{
    public int SomeStupidBlockingFunction(int c)
    {
        Thread.Sleep(800);
        return ++c;
    }
}

class UIThread
{
    public delegate void dlComandoMaquina();

    public class T0_SyncEvents
    {
        private EventWaitHandle _EventFechar; // Exit thread event

        public T0_SyncEvents()
        {
            _EventFechar = new ManualResetEvent(false);
        }

        public EventWaitHandle EventFecharThread // Exit thread event
        {
            get { return _EventFechar; }
        }
    }

    public class T0_Thread
    {
        private T0_SyncEvents _syncEvents;
        private int _msTimeOut;

        private dlComandoMaquina _ComandoMaquina;

        public T0_Thread(T0_SyncEvents e, dlComandoMaquina ComandoMaquina, int msTimeOut)
        {
            _syncEvents = e;
            _msTimeOut = msTimeOut;
            _ComandoMaquina = ComandoMaquina;
        }

        public void VaiRodar() // thread running code
        {
            while (!_syncEvents.EventFecharThread.WaitOne(_msTimeOut, false))
            {
                _ComandoMaquina();
            }

        }
    }
}

public partial class Form1 : Form
{
    MegaAPI tty;

    UIThread.T0_Thread thr1;
    UIThread.T0_SyncEvents thrE1;
    Thread Thread1;
    int ACount1 = 0;

    void UIUpdate1()
    {
        lock (tty)
        {
            ACount1 = tty.SomeStupidBlockingFunction(ACount1);
        }
        this.BeginInvoke((Action)delegate { txtAuto1.Text = ACount1.ToString(); });
    }

    UIThread.T0_Thread thr2;
    UIThread.T0_SyncEvents thrE2;
    Thread Thread2;
    int ACount2 = 0;

    void UIUpdate2()
    {
        lock (tty)
        {
            ACount2 = tty.SomeStupidBlockingFunction(ACount2);
        }
        this.BeginInvoke((Action)delegate { txtAuto2.Text = ACount2.ToString(); });
    }

    UIThread.T0_Thread thr3;
    UIThread.T0_SyncEvents thrE3;
    Thread Thread3;
    int ACount3 = 0;

    void UIUpdate3()
    {
        lock (tty)
        {
            ACount3 = tty.SomeStupidBlockingFunction(ACount3);
        }
        this.BeginInvoke((Action)delegate { txtAuto3.Text = ACount3.ToString(); });
    }

    UIThread.T0_Thread thr4;
    UIThread.T0_SyncEvents thrE4;
    Thread Thread4;
    int ACount4 = 0;

    void UIUpdate4()
    {
        lock (tty)
        {
            ACount4 = tty.SomeStupidBlockingFunction(ACount4);
        }
        this.BeginInvoke((Action)delegate { txtAuto4.Text = ACount4.ToString(); });
    }


    public Form1()
    {
        InitializeComponent();

        tty = new MegaAPI();

        thrE1 = new UIThread.T0_SyncEvents();
        thr1 = new UIThread.T0_Thread(thrE1, UIUpdate1, 500);
        Thread1 = new Thread(thr1.VaiRodar);
        Thread1.Start();

        thrE2 = new UIThread.T0_SyncEvents();
        thr2 = new UIThread.T0_Thread(thrE2, UIUpdate2, 500);
        Thread2 = new Thread(thr2.VaiRodar);
        Thread2.Start();

        thrE3 = new UIThread.T0_SyncEvents();
        thr3 = new UIThread.T0_Thread(thrE3, UIUpdate3, 500);
        Thread3 = new Thread(thr3.VaiRodar);
        Thread3.Start();

        thrE4 = new UIThread.T0_SyncEvents();
        thr4 = new UIThread.T0_Thread(thrE4, UIUpdate4, 500);
        Thread4 = new Thread(thr4.VaiRodar);
        Thread4.Start();

    }

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        thrE1.EventFecharThread.Set();
        thrE2.EventFecharThread.Set();
        thrE3.EventFecharThread.Set();
        thrE4.EventFecharThread.Set();

        Thread1.Join();
        Thread2.Join();
        Thread3.Join();
        Thread4.Join();
    }

    int Mcount = 0;
    private void btManual_Click(object sender, EventArgs e)
    {
        Cursor.Current = Cursors.WaitCursor;

        lock (tty)  // locks here ! Never runs inside! But the other threads keep counting..
        {
            Mcount = tty.SomeStupidBlockingFunction(Mcount);
            txtManual.Text = Mcount.ToString();
        }
        Cursor.Current = Cursors.Default;
    }
}

Answer 1

我怀疑您正在使用 Windows 消息循环和 WinForms 中的线程来解决问题。我不知道那是什么，但这里有一些提示：

您可以在backgroundWorker 中运行按钮的任务，以使工作脱离UI 线程。这样就解决了锁的问题。从工具箱中拖动一个BackgroundWorker并将其放在设计器中的Form上，然后连接该事件，即：

this.backgroundWorker1.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorker1_DoWork);

然后在btManual_Click中切换代码以像这样调用后台工作者：

backgroundWorker1.RunWorkerAsync();

然后：

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
    Mcount = tty.SomeStupidBlockingFunction(Mcount);
    this.BeginInvoke((Action)delegate { txtManual.Text = Mcount.ToString(); });
}

我已经省略了锁（tty ）因为我宁愿在函数内部只看到这些语句之一，而不是在外部看到五个语句。我不会锁定 tty，而是创建一个像这样的私有变量：

public class MegaAPI
{
    private object sync = new object();

    public int SomeStupidBlockingFunction(int c)
    {
        lock (this.sync)
        {
            Thread.Sleep(800);
            return ++c;                
        }
    }
}

然后其他地方都会被简化，例如：

void UIUpdate1()
{
    ACount1 = tty.SomeStupidBlockingFunction(ACount1);
    this.BeginInvoke((Action)delegate { txtAuto1.Text = ACount1.ToString(); });
}

由于您无法在后台工作程序仍在处理时运行它，因此这里有一个快速而肮脏的解决方案：在按钮工作时禁用它：

this.backgroundWorker1.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker1_RunWorkerCompleted);

然后：

private void btManual_Click(object sender, EventArgs e)
{
    this.btManual.Enabled = false;
    backgroundWorker1.RunWorkerAsync();
}

和：

private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    this.btManual.Enabled = true;
}

所以我建议：

• 保留单个 lock () 语句
  在需要的函数内部
  同步
• 保持锁定对象私有
• 在后台工作人员上运行工作

Answer 2

默认情况下，互斥体不提供公平性。它们只是保证您的整个流程将会取得进展。实现的工作是根据调度程序的特性等选择最佳线程来获取互斥锁。编码人员的工作是确保获取互斥体的线程执行程序需要完成的任何工作。

如果“错误的线程”获取互斥锁对您来说是个问题，那么您就做错了。互斥锁适用于没有“错误线程”的情况。如果您需要公平性或可预测的调度，则需要使用提供它的锁定原语或使用线程优先级。

当持有互斥体的线程不受 CPU 限制时，互斥体往往会以奇怪的方式起作用。您的线程获取互斥锁，然后自行重新调度。这将导致退化的调度行为，就像您所看到的行为一样。 （当然，它们不会违反保证，但它们的行为不会像理论上完美的互斥锁一样，也提供了公平性之类的东西。）