C# 串口在关闭时候死锁的解决方法

最新推荐文章于 2022-10-23 20:56:42 发布

mahushen

最新推荐文章于 2022-10-23 20:56:42 发布

阅读量1.1k

点赞数 1

分类专栏： C#

本文链接：https://blog.csdn.net/mahushen/article/details/8238195

版权

C# 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

摘自：http://blog.csdn.net/wuyazhe/archive/2010/05/19/5606276.aspx

作者：

用过微软SerialPort类的人，都遇到过这个尴尬，关闭串口的时候会让软件死锁。先看如下代码：
01.void comm_DataReceived(object sender, SerialDataReceivedEventArgs e)
02.{
03.    //先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
04.    int n = comm.BytesToRead;
05.    //声明一个临时数组存储当前来的串口数据
06.    byte[] buf = new byte[n];
07.    //增加接收计数
08.    received_count += n;
09.    //读取缓冲数据
10.    comm.Read(buf, 0, n);
11.    //清除字符串构造器的内容
12.    builder.Clear();
13.    //因为要访问ui资源，所以需要使用invoke方式同步ui。
14.    this.Invoke((EventHandler)(delegate{...界面更新，略}));
15.}
16.
17.private void buttonOpenClose_Click(object sender, EventArgs e)
18.{
19.    //根据当前串口对象，来判断操作
20.    if (comm.IsOpen)
21.    {
22.        //打开时点击，则关闭串口
23.        comm.Close();//这里就是可能导致软件死掉的地方
24.    }
25.    else
26.    {...}
27.}
void comm_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
    //先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
    int n = comm.BytesToRead;
    //声明一个临时数组存储当前来的串口数据
    byte[] buf = new byte[n];
    //增加接收计数
    received_count += n;
    //读取缓冲数据
    comm.Read(buf, 0, n);
    //清除字符串构造器的内容
    builder.Clear();
    //因为要访问ui资源，所以需要使用invoke方式同步ui。
    this.Invoke((EventHandler)(delegate{...界面更新，略}));
}

private void buttonOpenClose_Click(object sender, EventArgs e)
{
    //根据当前串口对象，来判断操作
    if (comm.IsOpen)
    {
        //打开时点击，则关闭串口
        comm.Close();//这里就是可能导致软件死掉的地方
    }
    else
    {...}
}

为什么会死锁呢，并发冲突。

我们要了解一下SerialPort的实现和串口通讯机制，在你打开串口的时候，SerialPort会创建一个监听线程ListenThread，在这个线程中，等待注册的串口中断，当收到中断后，会调用DataReceived事件。调用完成后，继续进入循环等待，直到串口被关闭退出线程。

我们的UI主线程如何做的呢，首先创建一个窗体，然后执行了Application.Run(窗体实例)。是这样把，这里的Application.Run就是创建了一个消息循环，循环的处理相关的消息。

这里我们就有了2个线程，UI主线程、串口监听线程。那么你在DataReceived处理数据的时候，就需要线程同步，避免并发冲突，什么是并发冲突？并发冲突就是2个或多个并行(至少看上去像)的线程运行的时候，多个线程共同的操作某一线程的资源，在时序上同时或没有按我们的预计顺序操作，这样就可能导致数据混乱无序或是彼此等待完成死锁软件。

而串口程序大多是后者。为什么呢，看看我们的例子中DataReceived做了什么？首先读取数据，然后就是调用this.Invoke方法更新UI了。这里Invoke的时候，监听线程将等待UI线程的标志，等到后，开始操作UI的资源，当操作完成之前，监听线程也就停在DataReceived方法的调用这里，如果这个时候。并发了关闭串口的操作会如何呢？SerialPort的Close方法，会首先尝试等待和监听线程一样的一个互斥体、临界区、或是事件（不确定.net用的哪种）。那这个同步对象什么时候释放呢？每次循环结束就释放，哦。循环为什么不结束呢？因为这一次的循环操作执行到DataReceived之后，执行了Invoke去更新界面了，那Invoke怎么又没有执行完成呢？看上去很简单的几行代码。虽然我没仔细研读过.net的Invoke原理，但我猜测是通过消息的方式来同步的，这也是为什么这么多的类，只有控件（窗体也是控件的一种，.net在概念上，颠覆了微软自己的概念，传统的win32编程，是说所有的控件都是个window，只是父窗体不同，表现形式不同，但都是基于系统消息队列的，.net出于更高的抽象，正好反过来了。呵呵）才有Invoke方法了。(委托自己的Invoke和这个不同)

我猜测控件/窗体的Invoke是SendMessage方式实现的，那么发送消息后就会等待消息循环来处理消息了。如果你直接去关闭串口了。你点击按钮本身也会被转换成消息WM_CLICK，消息循环在处理按钮的WM_CLICK时候，调用你按钮的OnClick方法，进而触发调用你的ButtonClose_Click事件，这都是同步调用的，你的主线程，处理消息的过程，停在了这个Click事件，而你的Click事件又去调用了SerialPort的Close方法，Close方法又因为和串口监听线程的同步信号量关联在一起需要等待一次的while结束，而这个while循环中调用了DataReceived方法，这个方法中调用了Invoke，也就是发送了消息到消息队列等待结果，但消息循环正在处理你的关闭按钮事件等待退出。

实在太复杂了，这个情况下，你想要真的关闭串口成功，就需要while中的DataReceived方法调用结束释放同步信号，就需要执行完Invoke，就需要执行消息循环，幸运的是，我们真的有办法执行消息循环来打破僵局。Application.DoEvents()。还好，不幸中的万幸。可是问题又来了，你能让Invoke结束，但你无法确定是否在你调用消息循环后，你的某一时刻不会再次并发，可能由于单cpu的串行操作模拟并行中，又把时间片先分给了优先级高的串口监听线程呢？是有可能的。所以，我们就需要一点方法来避免再次invoke窗体。优化后不会司机的例子如下，我们修改DataReceived方法，关闭方法，并定义2个标记Listening和Closing。

view plaincopy to clipboardprint?
01.using System;
02.using System.Collections.Generic;
03.using System.ComponentModel;
04.using System.Data;
05.using System.Drawing;
06.using System.Linq;
07.using System.Text;
08.using System.Windows.Forms;
09.using System.IO.Ports;
10.using System.Text.RegularExpressions;
11.
12.namespace SerialportSample
13.{
14.    public partial class SerialportSampleForm : Form
15.    {
16.        private SerialPort comm = new SerialPort();
17.        private StringBuilder builder = new StringBuilder();//避免在事件处理方法中反复的创建，定义到外面。
18.        private long received_count = 0;//接收计数
19.        private long send_count = 0;//发送计数
20.        private bool Listening = false;//是否没有执行完invoke相关操作
21.        private bool Closing = false;//是否正在关闭串口，执行Application.DoEvents，并阻止再次invoke
22.
23.        public SerialportSampleForm()
24.        {
25.            InitializeComponent();
26.        }
27.
28.        //窗体初始化
29.        private void Form1_Load(object sender, EventArgs e)
30.        {
31.            //初始化下拉串口名称列表框
32.            string[] ports = SerialPort.GetPortNames();
33.            Array.Sort(ports);
34.            comboPortName.Items.AddRange(ports);
35.            comboPortName.SelectedIndex = comboPortName.Items.Count > 0 ? 0 : -1;
36.            comboBaudrate.SelectedIndex = comboBaudrate.Items.IndexOf("9600");
37.
38.            //初始化SerialPort对象
39.            comm.NewLine = "\r\n";
40.            comm.RtsEnable = true;//根据实际情况吧。
41.
42.            //添加事件注册
43.            comm.DataReceived += comm_DataReceived;
44.        }
45.
46.        void comm_DataReceived(object sender, SerialDataReceivedEventArgs e)
47.        {
48.            if (Closing) return;//如果正在关闭，忽略操作，直接返回，尽快的完成串口监听线程的一次循环
49.            try
50.            {
51.                Listening = true;//设置标记，说明我已经开始处理数据，一会儿要使用系统UI的。
52.                int n = comm.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
53.                byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据
54.                received_count += n;//增加接收计数
55.                comm.Read(buf, 0, n);//读取缓冲数据
56.                builder.Clear();//清除字符串构造器的内容
57.                //因为要访问ui资源，所以需要使用invoke方式同步ui。
58.                this.Invoke((EventHandler)(delegate
59.                {
60.                    //判断是否是显示为16禁止
61.                    if (checkBoxHexView.Checked)
62.                    {
63.                        //依次的拼接出16进制字符串
64.                        foreach (byte b in buf)
65.                        {
66.                            builder.Append(b.ToString("X2") + " ");
67.                        }
68.                    }
69.                    else
70.                    {
71.                        //直接按ASCII规则转换成字符串
72.                        builder.Append(Encoding.ASCII.GetString(buf));
73.                    }
74.                    //追加的形式添加到文本框末端，并滚动到最后。
75.                    this.txGet.AppendText(builder.ToString());
76.                    //修改接收计数
77.                    labelGetCount.Text = "Get:" + received_count.ToString();
78.                }));
79.            }
80.            finally
81.            {
82.                Listening = false;//我用完了，ui可以关闭串口了。
83.            }
84.        }
85.
86.        private void buttonOpenClose_Click(object sender, EventArgs e)
87.        {
88.            //根据当前串口对象，来判断操作
89.            if (comm.IsOpen)
90.            {
91.                Closing = true;
92.                while (Listening) Application.DoEvents();
93.                //打开时点击，则关闭串口
94.                comm.Close();
95.                Closing = false;
96.            }
97.            else
98.            {
99.                //关闭时点击，则设置好端口，波特率后打开
100.                comm.PortName = comboPortName.Text;
101.                comm.BaudRate = int.Parse(comboBaudrate.Text);
102.                try
103.                {
104.                    comm.Open();
105.                }
106.                catch(Exception ex)
107.                {
108.                    //捕获到异常信息，创建一个新的comm对象，之前的不能用了。
109.                    comm = new SerialPort();
110.                    //现实异常信息给客户。
111.                    MessageBox.Show(ex.Message);
112.                }
113.            }
114.            //设置按钮的状态
115.            buttonOpenClose.Text = comm.IsOpen ? "Close" : "Open";
116.            buttonSend.Enabled = comm.IsOpen;
117.        }
118.
119.        //动态的修改获取文本框是否支持自动换行。
120.        private void checkBoxNewlineGet_CheckedChanged(object sender, EventArgs e)
121.        {
122.            txGet.WordWrap = checkBoxNewlineGet.Checked;
123.        }
124.
125.        private void buttonSend_Click(object sender, EventArgs e)
126.        {
127.            //定义一个变量，记录发送了几个字节
128.            int n = 0;
129.            //16进制发送
130.            if (checkBoxHexSend.Checked)
131.            {
132.                //我们不管规则了。如果写错了一些，我们允许的，只用正则得到有效的十六进制数
133.                MatchCollection mc = Regex.Matches(txSend.Text, @"(?i)[\da-f]{2}");
134.                List<byte> buf = new List<byte>();//填充到这个临时列表中
135.                //依次添加到列表中
136.                foreach (Match m in mc)
137.                {
138.                    buf.Add(byte.Parse(m.Value));
139.                }
140.                //转换列表为数组后发送
141.                comm.Write(buf.ToArray(), 0, buf.Count);
142.                //记录发送的字节数
143.                n = buf.Count;
144.            }
145.            else//ascii编码直接发送
146.            {
147.                //包含换行符
148.                if (checkBoxNewlineSend.Checked)
149.                {
150.                    comm.WriteLine(txSend.Text);
151.                    n = txSend.Text.Length + 2;
152.                }
153.                else//不包含换行符
154.                {
155.                    comm.Write(txSend.Text);
156.                    n = txSend.Text.Length;
157.                }
158.            }
159.            send_count += n;//累加发送字节数
160.            labelSendCount.Text = "Send:" + send_count.ToString();//更新界面
161.        }
162.
163.        private void buttonReset_Click(object sender, EventArgs e)
164.        {
165.            //复位接受和发送的字节数计数器并更新界面。
166.            send_count = received_count = 0;
167.            labelGetCount.Text = "Get:0";
168.            labelSendCount.Text = "Send:0";
169.        }
170.    }
171.}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO.Ports;
using System.Text.RegularExpressions;

namespace SerialportSample
{
    public partial class SerialportSampleForm : Form
    {
        private SerialPort comm = new SerialPort();
        private StringBuilder builder = new StringBuilder();//避免在事件处理方法中反复的创建，定义到外面。
        private long received_count = 0;//接收计数
        private long send_count = 0;//发送计数
        private bool Listening = false;//是否没有执行完invoke相关操作
        private bool Closing = false;//是否正在关闭串口，执行Application.DoEvents，并阻止再次invoke

        public SerialportSampleForm()
        {
            InitializeComponent();
        }

        //窗体初始化
        private void Form1_Load(object sender, EventArgs e)
        {
            //初始化下拉串口名称列表框
            string[] ports = SerialPort.GetPortNames();
            Array.Sort(ports);
            comboPortName.Items.AddRange(ports);
            comboPortName.SelectedIndex = comboPortName.Items.Count > 0 ? 0 : -1;
            comboBaudrate.SelectedIndex = comboBaudrate.Items.IndexOf("9600");

            //初始化SerialPort对象
            comm.NewLine = "\r\n";
            comm.RtsEnable = true;//根据实际情况吧。

            //添加事件注册
            comm.DataReceived += comm_DataReceived;
        }

        void comm_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            if (Closing) return;//如果正在关闭，忽略操作，直接返回，尽快的完成串口监听线程的一次循环
            try
            {
                Listening = true;//设置标记，说明我已经开始处理数据，一会儿要使用系统UI的。
                int n = comm.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
                byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据
                received_count += n;//增加接收计数
                comm.Read(buf, 0, n);//读取缓冲数据
                builder.Clear();//清除字符串构造器的内容
                //因为要访问ui资源，所以需要使用invoke方式同步ui。
                this.Invoke((EventHandler)(delegate
                {
                    //判断是否是显示为16禁止
                    if (checkBoxHexView.Checked)
                    {
                        //依次的拼接出16进制字符串
                        foreach (byte b in buf)
                        {
                            builder.Append(b.ToString("X2") + " ");
                        }
                    }
                    else
                    {
                        //直接按ASCII规则转换成字符串
                        builder.Append(Encoding.ASCII.GetString(buf));
                    }
                    //追加的形式添加到文本框末端，并滚动到最后。
                    this.txGet.AppendText(builder.ToString());
                    //修改接收计数
                    labelGetCount.Text = "Get:" + received_count.ToString();
                }));
            }
            finally
            {
                Listening = false;//我用完了，ui可以关闭串口了。
            }
        }

        private void buttonOpenClose_Click(object sender, EventArgs e)
        {
            //根据当前串口对象，来判断操作
            if (comm.IsOpen)
            {
                Closing = true;
                while (Listening) Application.DoEvents();
                //打开时点击，则关闭串口
                comm.Close();
                Closing = false;
            }
            else
            {
                //关闭时点击，则设置好端口，波特率后打开
                comm.PortName = comboPortName.Text;
                comm.BaudRate = int.Parse(comboBaudrate.Text);
                try
                {
                    comm.Open();
                }
                catch(Exception ex)
                {
                    //捕获到异常信息，创建一个新的comm对象，之前的不能用了。
                    comm = new SerialPort();
                    //现实异常信息给客户。
                    MessageBox.Show(ex.Message);
                }
            }
            //设置按钮的状态
            buttonOpenClose.Text = comm.IsOpen ? "Close" : "Open";
            buttonSend.Enabled = comm.IsOpen;
        }

        //动态的修改获取文本框是否支持自动换行。
        private void checkBoxNewlineGet_CheckedChanged(object sender, EventArgs e)
        {
            txGet.WordWrap = checkBoxNewlineGet.Checked;
        }

        private void buttonSend_Click(object sender, EventArgs e)
        {
            //定义一个变量，记录发送了几个字节
            int n = 0;
            //16进制发送
            if (checkBoxHexSend.Checked)
            {
                //我们不管规则了。如果写错了一些，我们允许的，只用正则得到有效的十六进制数
                MatchCollection mc = Regex.Matches(txSend.Text, @"(?i)[\da-f]{2}");
                List<byte> buf = new List<byte>();//填充到这个临时列表中
                //依次添加到列表中
                foreach (Match m in mc)
                {
                    buf.Add(byte.Parse(m.Value));
                }
                //转换列表为数组后发送
                comm.Write(buf.ToArray(), 0, buf.Count);
                //记录发送的字节数
                n = buf.Count;
            }
            else//ascii编码直接发送
            {
                //包含换行符
                if (checkBoxNewlineSend.Checked)
                {
                    comm.WriteLine(txSend.Text);
                    n = txSend.Text.Length + 2;
                }
                else//不包含换行符
                {
                    comm.Write(txSend.Text);
                    n = txSend.Text.Length;
                }
            }
            send_count += n;//累加发送字节数
            labelSendCount.Text = "Send:" + send_count.ToString();//更新界面
        }

        private void buttonReset_Click(object sender, EventArgs e)
        {
            //复位接受和发送的字节数计数器并更新界面。
            send_count = received_count = 0;
            labelGetCount.Text = "Get:0";
            labelSendCount.Text = "Send:0";
        }
    }
}

至此，不会再出现关闭死锁问题了。

mahushen

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C# 串口在关闭时候死锁的解决方法

摘自：http://blog.csdn.net/wuyazhe/archive/2010/05/19/5606276.aspx 作者：用过微软SerialPort类的人，都遇到过这个尴尬，关闭串口的时候会让软件死锁。先看如下代码： 01.void comm_DataReceived(object sender, SerialDataReceivedEventArgs e) 02.
复制链接

扫一扫