for (int i = 0; i < axiss.Length; i++)
{
int axis = axiss[i];
LogHelper.Write($"1--执行的轴号是{axis}");
var dyminW = new DummyWork2();
dyminW.ZMotionDammyReady += new DummyWork2.ZAxisDyminWorkingEndEvent(OnDyminWorkingEnd);
dyminW.zAxisDyminDropSenderEnd += new DummyWork2.ZAxisDyminDropSenderEndEvent(DropSender);
dyminW.Start(axis, 0);
LogHelper.Write($"2--执行的轴号是{axis}");
dummyWork2s.Add(dyminW);
}
通过上面的方式去调用下面的代码，下面的代码里面会经常使用Task.Run()异步线程进行硬件操作，最多一次控制6个轴（也就是new 6个DummyWork2），轴操作分为回吸运动和滴下运动，没管大概10000000的量，每次滴下大概1-20000,现在需要6个轴一起连续滴多少次（客户设置一般800-2000次）。现在遇到一个问题，就是我运动过程中会有某个轴突然停止运动，似乎是线程假死，有时候哪个轴就直接停止运动，有时候突然过段时间又开始运动，有的时候开启下次任务时，突然又接着上次的任务次数接着运动。哪位大佬帮忙看看，怎么解决？
public class DummyWork2
{
public delegate void ZAxisDyminWorkingEndEvent(int axis, bool success);
/// <summary>
/// 轴工作已完成触发
/// </summary>
public ZAxisDyminWorkingEndEvent ZMotionDammyReady;
public delegate void ZAxisDyminDropSenderEndEvent(int axis, int dropNum, int num);
public ZAxisDyminDropSenderEndEvent zAxisDyminDropSenderEnd;
public int Suckvalue;
public int SuckSpeed;
public int DropSpeed;
public int DropPulse;
public int DropNumber;
public int DyminNum;
public int DummyStartNum;
public int Axis = -1;
public int Num = 1;
public int IntervalTime = Commond.Commond.ReadJson.typeNumber.IntervalTime;
///获取每个轴的回吸量
public int SuckUnm()
{
try
{
LogHelper.Write($"{Axis}轴SuckUnm start！");
int position = 0;
var ans = Commond.Commond.Mc210Contorl.SscGetPosition(1, 1, Axis + 1, out position);
if (ans != "success")
{
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_OPERATION);
Thread.Sleep(50);
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_SYSTEM);
Thread.Sleep(50);
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_SERVO);
Thread.Sleep(50);
SuckUnm();
}
var number = Convert.ToInt32(Commond.Commond.ReadJson.auto[Axis].SuckValue) - Convert.ToInt32(position);
LogHelper.Write($"{Axis}轴SuckUnm end！");
return number;
}
catch (Exception ex) { return 0; }
}
System.Threading.Timer _SuckState;
///回吸动作
public void Suck(int dummyStartNum)
{
try
{
CancellationTokenSource cts = new CancellationTokenSource();
Task.Run(() =>
{
try
{
LogHelper.Write($"{Axis}轴回吸开始！");
DummyStartNum = dummyStartNum;
Suckvalue = SuckUnm();
LogHelper.Write($"{Axis}轴回吸量：{Suckvalue}！");
ZMotionTools.SetOp(Commond.Commond.IOConfig.ValveReverse[Axis], 0);
ZMotionTools.SetOp(Commond.Commond.IOConfig.ValveCorotation[Axis], 1);
if (Commond.Commond.Mc210WorkingStop)
{
LogHelper.Write($"{Axis}轴停止任务！");
_SuckState.Dispose();
cts.Cancel();
cts.Dispose();
AxisState = 1;
return;
}
var ret = Commond.Commond.Mc210Contorl.SscIncStart(1, 1, Axis + 1, Suckvalue, SuckSpeed, 1, 3);
if (ret != "success")
{
LogHelper.Write($"{Axis}轴回吸失败！");
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_OPERATION);
Thread.Sleep(50);
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_SYSTEM);
Thread.Sleep(50);
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_SERVO);
Thread.Sleep(50);
if (Commond.Commond.Mc210WorkingStop)
{
LogHelper.Write($"{Axis}轴停止任务！");
_SuckState.Dispose();
cts.Cancel();
cts.Dispose();
AxisState = 1;
return;
}
ret = Commond.Commond.Mc210Contorl.SscIncStart(1, 1, Axis + 1, Suckvalue, SuckSpeed, 1, 3);
if (ret != "success")
{
cts.Cancel();
cts.Dispose();
AxisState = 1;
WarnTools.Warn($"{Axis + 1}轴回吸失败", WarnTypeENum.P轴报警, true, 1);
LogHelper.Write($"{Axis + 1}轴回吸失败");
return;
}
}
int Timeout = Convert.ToInt32(Suckvalue / (SuckSpeed));
int count = 0;
int state;
_SuckState = new Timer((s) =>
{
if (Commond.Commond.Mc210WorkingStop)
{
LogHelper.Write($"{Axis}轴停止任务！");
_SuckState.Dispose();
cts.Cancel();
cts.Dispose();
AxisState = 1;
return;
}
var status = Commond.Commond.Mc210Contorl.SscGetDriveFinStatus(1, 1, Axis + 1, SscApi.SSC_FIN_TYPE_SMZ, out state);
if (status == "success")
{
if (state == 1)
{
_SuckState.Dispose();
LogHelper.Write($"{Axis}轴回吸完成，开始第{dummyStartNum}任务！");
cts.Cancel();
cts.Dispose();
Dummy();
}
}
else
{
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_OPERATION);
Thread.Sleep(50);
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_SYSTEM);
Thread.Sleep(50);
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_SERVO);
Thread.Sleep(50);
}
if (count > 20)
{
_SuckState.Dispose();
cts.Cancel();
cts.Dispose();
AxisState = 1;
WarnTools.Warn($"{Axis + 1}轴吐料模式回吸超时！", WarnTypeENum.P轴报警, true, 1);
LogHelper.Write($"{Axis + 1}轴吐料模式回吸超时");
return;
}
count++;
}, null, Timeout, 500);
}
catch (Exception ex)
{
cts.Cancel();
cts.Dispose();
AxisState = 1;
WarnTools.Warn($"{Axis + 1}轴吐料模式回吸错误：{ex.Message}！", WarnTypeENum.P轴报警, true, 1);
LogHelper.Write($"{Axis + 1}轴吐料模式回吸错误：{ex.Message}");
}
}, cts.Token);
}
catch (Exception ex)
{
LogHelper.Write($"{Axis + 1}轴吐料模式回吸错误：{ex.Message}");
AxisState = 1;
}
}
///滴下动作，当剩余的量不够滴下动作时回吸
public void Dummy()
{
CancellationTokenSource cts = new CancellationTokenSource();
LogHelper.Write($"Dummy Start1->{Axis} DummyStartNum {DummyStartNum} DyminNum {DyminNum}");
var dummy = Task.Run(() =>
{
try
{
LogHelper.Write($"Dummy Start2->{Axis}");
for (int i = DummyStartNum; i < DyminNum; i++)
{
ZMotionTools.SetOp(Commond.Commond.IOConfig.ValveReverse[Axis], 0);
ZMotionTools.SetOp(Commond.Commond.IOConfig.ValveCorotation[Axis], 0);
DropSenser.Zero(DropSenserNum(Axis));
for (int j = 0; j < DropNumber; j++)
{
if (Commond.Commond.Mc210WorkingStop)
{
cts.Cancel();
cts.Dispose();
AxisState = 1;
LogHelper.Write($"Dummy stop->{Axis}");
return;
}
var ret = Commond.Commond.Mc210Contorl.SscIncStart(1, 1, Axis + 1, -DropPulse, DropSpeed, 1, 5);
if (ret == "success")
{
Thread.Sleep(Convert.ToInt32(Commond.Commond.ReadJson.auto[Axis].DropInterval) + Convert.ToInt32(DropPulse / (DropSpeed)));
}
else
{
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_OPERATION);
Thread.Sleep(10);
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_SYSTEM);
Thread.Sleep(10);
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_SERVO);
Thread.Sleep(10);
Commond.Commond.Mc210Contorl.SscIncStart(1, 1, Axis + 1, -DropPulse, DropSpeed, 1, 5);
}
}
zAxisDyminDropSenderEnd?.Invoke(Axis, DropSenser.GetCount(DropSenserNum(Axis)), i + 1);
int position = 0;
var ans = Commond.Commond.Mc210Contorl.SscGetPosition(1, 1, Axis + 1, out position);
if (ans != "success")
{
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_OPERATION);
Thread.Sleep(50);
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_SYSTEM);
Thread.Sleep(50);
Commond.Commond.Mc210Contorl.SscResetAlarm(1, 1, Axis + 1, SscApi.SSC_ALARM_SERVO);
Thread.Sleep(50);
Commond.Commond.Mc210Contorl.SscGetPosition(1, 1, Axis + 1, out position);
}
if (position > DropPulse * DropNumber)
{
Thread.Sleep(IntervalTime);
}
else
{
cts.Cancel();
cts.Dispose();
Suck(i + 1);
return;
}
}
AxisState = 1;
return;
}
catch (Exception ex)
{
cts.Cancel();
cts.Dispose();
WarnTools.Warn($"{Axis}轴Dummy运动错误：{ex.Message}", WarnTypeENum.P轴报警, true, 1);
LogHelper.Write($"{Axis}轴Dummy运动错误：{ex.Message}");
AxisState = 1;
}
}, cts.Token);
}
public int DropSenserNum(int input)
{
try
{
int num = 0;
switch (input)
{
case 0:
num = Commond.Commond.IOConfig.InputAxis0DorpSenser;
break;
case 1:
num = Commond.Commond.IOConfig.InputAxis1DorpSenser;
break;
case 2:
num = Commond.Commond.IOConfig.InputAxis2DorpSenser;
break;
case 3:
num = Commond.Commond.IOConfig.InputAxis3DorpSenser;
break;
case 4:
num = Commond.Commond.IOConfig.InputAxis4DorpSenser;
break;
case 5:
num = Commond.Commond.IOConfig.InputAxis5DorpSenser;
break;
default:
num = 0;
break;
}
return num;
}
catch (Exception ex)
{
return -1;
}
}
public void Start(int axis, int type)
{
CancellationTokenSource cts = new CancellationTokenSource();
var a = Task.Run(() =>
{
try
{
//工作流程
//状态监听
Axis = axis;
SuckSpeed = Commond.Commond.UCMppConditions.MPPSuckSpeed[axis];
DropSpeed = Commond.Commond.UCMppConditions.MPPDropSpeed[axis];
DropPulse = Convert.ToInt32(Commond.Commond.ReadJson.auto[axis].StandardPulse);
DropNumber = Convert.ToInt16(Commond.Commond.ReadJson.auto[axis].DropCount);
if (type == 0)
Num = Commond.Commond.ReadJson.typeNumber.DyminNum;
else
Num = Commond.Commond.ReadJson.typeNumber.Dymin2Num;
Suckvalue = Convert.ToInt32(Commond.Commond.ReadJson.auto[Axis].SuckValue);
DyminNum = Convert.ToInt32(Suckvalue / (DropPulse * DropNumber)) * Num;
LogHelper.Write($"Start的轴号是{Axis}");
if (Commond.Commond.Mc210WorkingStop)
{
LogHelper.Write($"{Axis}轴停止任务！");
_SuckState.Dispose();
cts.Cancel();
cts.Dispose();
AxisState = 1;
return;
}
cts.Cancel();
cts.Dispose();
Suck(0);
}
catch (Exception ex)
{
cts.Cancel();
cts.Dispose();
WarnTools.Warn($"{axis + 1}轴运动报错：{ex.Message}", WarnTypeENum.P轴报警, true, 1);
AxisState = 1;
}
}, cts.Token);
}
public int axisState;
public int AxisState
{
get => axisState;
set
{
axisState = value;
if (axisState == 1)
{
LogHelper.Write($"{Axis}轴完成");
ZMotionDammyReady?.Invoke(Axis, true);
}
}
}
}
C#多线程假死或卡死问题
- 写回答
- 好问题 0 提建议
- 关注问题
分享- 邀请回答
-
40条回答 默认 最新
M_try的小尾巴 2024-11-27 10:54关注获得0.15元问题酬金 提示： 本回答参考 AIGC，由本人审核整理提供。若问题解决，望采纳；如仍有疑问，请评论回复。
问题分析
从代码和描述来看，问题主要集中在多线程操作中，特别是使用
Task.Run()进行硬件操作时，某些轴可能会突然停止运动，表现为线程假死或卡死。这种情况可能是由于以下几个原因导致的：- 资源竞争：多个线程同时访问和修改共享资源，导致资源竞争和死锁。
- 硬件操作阻塞：硬件操作可能因为某些原因（如硬件故障、通信问题等）导致线程阻塞。
- 任务取消和异常处理：任务取消和异常处理不当可能导致线程无法正常结束。
- 线程同步问题：线程间的同步机制可能存在问题，导致某些线程无法正常执行。
解决方案
1. 资源竞争问题
确保所有共享资源（如硬件控制接口、状态变量等）在多线程环境下是线程安全的。可以使用
lock关键字或其他同步机制来保护共享资源。private readonly object _lock = new object(); public void Suck(int dummyStartNum) { lock (_lock) { // 保护共享资源的操作 } }2. 硬件操作阻塞问题
在硬件操作中加入超时机制，避免因硬件问题导致线程长时间阻塞。可以使用
Task.WaitAsync或CancellationToken来实现超时控制。public async Task SuckAsync(int dummyStartNum, CancellationToken cancellationToken) { try { var result = await Commond.Commond.Mc210Contorl.SscIncStartAsync(1, 1, Axis + 1, Suckvalue, SuckSpeed, 1, 3, cancellationToken); if (result != "success") { // 处理错误 } } catch (OperationCanceledException) { // 处理超时 } }3. 任务取消和异常处理
确保在任务取消时，所有资源都被正确释放，并且异常被正确捕获和处理。
public void Suck(int dummyStartNum) { using (var cts = new CancellationTokenSource()) { try { Task.Run(() => { try { // 任务逻辑 } catch (Exception ex) { // 异常处理 } }, cts.Token); } catch (Exception ex) { // 异常处理 } } }4. 线程同步问题
确保线程间的同步机制是正确的。可以使用
SemaphoreSlim或ManualResetEvent等同步原语来控制线程的执行顺序。private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1); public async Task SuckAsync(int dummyStartNum) { await _semaphore.WaitAsync(); try { // 任务逻辑 } finally { _semaphore.Release(); } }总结
通过以上方法，可以有效减少多线程操作中的假死或卡死问题。具体实施时，需要根据实际情况选择合适的同步机制和异常处理策略。同时，建议在开发过程中加入详细的日志记录，以便在问题发生时能够快速定位和解决问题。
评论 打赏解决 1无用举报 分享
- 2017-02-05 23:23总结，通过理解并运用这些多线程和异步编程技术，开发者可以在C#中有效地解决界面卡死问题，提高用户体验。然而，使用多线程也需注意线程安全和资源管理，避免引入新的问题。在实践中，选择最适合场景的技术是至关...
- 2021-10-31 14:11当两个或更多线程互相等待对方释放资源时，就会形成死锁。使用`Mutex`、`Semaphore`或`Monitor`等同步原语时，必须谨慎设计，以防止这种问题的发生。 在描述中提到了`progressBar1`，这可能意味着程序尝试更新UI...
- 2014-11-22 23:02然而，如果使用不当，多线程可能导致各种问题，其中“假死”（也称为应用程序无响应或UI冻结）是最常见的一种。本文将深入探讨如何正确调用多线程，以避免假死现象的发生。 首先，我们需要理解什么是假死。假死通常...
- 2020-09-03 16:22在C# WinForm应用程序开发中，常常遇到一个问题：当程序执行长时间的后台任务时，如循环处理或定时器触发的事件，可能导致用户界面（UI）变得反应迟钝，甚至出现假死现象。这是因为Windows消息队列中的事件无法得到...
- 2022-01-14 22:17_顾全大橘的博客 执行结果终于达到效果，无论这个耗时操作多慢，主界面一点都不卡，可以拖动窗口，可以最大化最小化，可以操作滚动条，可以点击其它按钮，当然也可以点某个按钮终止当前耗时操作……
- 2025-10-26 23:08威哥说编程的博客 解决假死的核心不是“用多线程”，而是“让线程各司其职”——UI线程专注响应用户，通信线程专注收发数据，处理线程专注业务逻辑，通过队列有序协作。本文的“三线分离”架构不仅适用于扫码枪系统，还能直接套用到...
- 2011-11-22 17:00通过研究这个项目，开发者可以学习如何在C#中有效地使用进度条，以及如何在没有多线程的情况下避免界面假死，这对于编写用户友好的桌面应用程序至关重要。同时，这也是一个很好的实践案例，展示了如何在有限的资源下...
- 2021-05-20 11:34weixin_39520199的博客 本文是对窗口卡死(假死)的应用问题进行一系列的探讨，旨在帮助对Windows应用程序不熟悉的新手理解这个问题。我将逐步的深入开发的过程，让你有一个循序渐进的思路。我这里就用MFC程序作为示例，当然win32程序或者C#...
- 2018-09-15 14:54嘴对嘴编程的博客 主要是对一个过程需要的时间很长执行时会出现界面假死的情况 方法1： Application.DoEvents()，这种方法当你拖动窗体时，界面不会假死。但在你拖动时代码不再执行，也就是阻塞了，当你不再控制窗体时会继续执行，...
- 2015-12-08 11:01邵鸿鑫的博客 在多线程编程中，如果你从非创建这个控件的线程中访问这个控件或者操作这个控件的话就会抛出这个异常。这是微软为了保证线程安全以及提高代码的效率所做的改进，但是也给大家带来很多不便。 今天我就遇到了一个类似...
- 没有解决我的问题, 去提问
问题事件
系统已结题
12月5日
创建了问题
11月27日