Question

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

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

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

1）当其他线程没有问题时，为什么表单线程中的lock（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限制时，互斥锁往往会以奇怪的方式运行。您的线程获取互斥锁，然后自行解决。这将导致退化的调度行为，就像您所看到的行为一样。（当然，他们不会破坏他们的保证，但他们的行为不会像理论上完美的互斥体那样提供公平的东西。）

无法理解：使用lock（）但从不执行代码

2 个答案: