c# 是不是也像仓颉一样,并发上:仓颉不能在编译期阻止数据竞争。多个线程同时可变访问同一个对象,编译不会报错,要你自己加锁、同步原语;而 Safe Rust 编译期就禁止 “同时可变别名”,从根源消灭数据竞争,这是最大差异点
对,C# 和仓颉在这一点上是同一类,和 Rust 有本质区别:
✅ C# 的情况
C# 编译器不会检查、也不会阻止多线程同时读写同一个共享对象。
class Data
{
public int Value;
}
var d = new Data();
// 两个线程同时写 d.Value,编译器完全放行,编译正常通过
Task.Run(() => d.Value++);
Task.Run(() => d.Value++);
上面这段代码:
- 编译能过,没有任何警告;
- 会出现数据竞争(race condition),结果错乱;
- 必须你自己手动
lock/Interlocked/ConcurrentXXX来保护。
C# 有
volatile、lock、Monitor、ConcurrentQueue这些同步工具,但全部是运行时层面的保护,编译器不帮你证明不存在竞争。
✅ 仓颉(Cangjie)和 C# 一样
仓颉的类型系统没有借用 / 所有权模型,不区分 “独占可变引用” 和 “共享只读引用”: 多个协程 / 线程拿到同一个对象的可变引用,编译器直接允许,不会报错。 竞态问题要自己用锁、通道、原子类型处理,和 C#、Go 思路一致。
✅ Safe Rust 是独一份
Safe Rust 的核心规则:同一时间,只能有一个可变引用,或者多个只读引用,不能同时存在可变别名。 只要你写出会导致数据竞争的代码,编译直接失败,在编译阶段就挡住这一类 bug。
let mut x = 0;
let p1 = &mut x;
let p2 = &mut x; // ❌ 编译报错,不允许两个可变引用同时存在
一张对照
表格
| 语言 | 编译期阻止数据竞争 | 内存安全方案 |
|---|---|---|
| Safe Rust | ✅ 可以,所有权系统静态保证 | 无 GC,编译期检查 |
| 仓颉 | ❌ 不能,靠开发者同步 | GC + 空安全 + 运行时边界检查 |
| C# | ❌ 不能,靠开发者同步 | GC + 运行时检查 |
| Go | ❌ 不能,靠开发者同步 | GC |
放到你的数采网关场景理解
你写 C# MES / 上位机这么多年应该深有体会:
点位池、实时数据对象、设备状态,多采集线程同时读写,稍不留神忘加锁就偶发错乱,这种 bug 最难复现。
- 换到仓颉:这个坑原样保留,不会因为换语言自动消失;开发体验上并发这块和 C# 很接近;
- 换到 Rust:只要不走
unsafe,编译器强制帮你避开这类坑,但代价是学习成本高、写业务代码啰嗦很多。
补充一个容易混淆的点
C# 有 readonly、仓颉也有 let(不可变绑定),但它们只是变量不能重新赋值,不代表对象内部不能改:
readonly Data d = new Data();
d.Value++; // 合法,依旧会并发竞争
仓颉同理:let devState = DevState{...} 只是 devState 不能指向别的对象,但 devState.temp = 123 依然可以在多线程里乱改。
💥💥💥💥C# lock💥💥💥
不是所有地方都无脑加 lock,要看是什么资源在并发访问,做 PLC 驱动(Modbus、三菱 MC、汇川这类)我给你按你平时 C# 上位机 / 数采网关的场景拆开讲,这个是你天天会碰到的。
前提:C# 编译器不检查数据竞争,和仓颉一样,共享可变状态才需要同步;只读、无共享的局部变量完全不用锁。
一、哪些场景【一定要锁】(高频踩坑,PLC 驱动重点)
PLC 驱动最典型的共享资源两类:
1. 同一个串口 / 同一个 TCP 连接(最最重要!)
比如一个 485 总线、一个 TCP Socket,多个采集任务同时往同一个连接发报文。
- Modbus RTU 串口:总线同一时刻只能有一帧在收发。两个 Task 同时 Send,报文直接乱套、CRC 错、返回串包、偶发超时。
- TCP 长连接(三菱 MC、ModbusTCP 长连接):Socket 是流式,并发发包会粘包、应答和请求对不上,返回数据张冠李戴。
✅ 标准写法:每个物理链路(串口 / 连接)单独一个锁对象,不要全局一把大锁(全局锁会把所有设备轮询排队,吞吐量卡死)
// 每个驱动实例自带锁,一个链路一把锁
private readonly object _ioLock = new object();
public async Task<ModbusResult> ReadReg(ushort addr, ushort count)
{
lock (_ioLock)
{
// 1. 组装报文
// 2. Send
// 3. 阻塞等待应答、超时、校验
// 4. 解析返回
}
}
注意:async 里面不能直接 lock!lock 是线程锁,await 会释放线程,很容易出问题。 👉 async IO(串口 / 网络异步读写)优先用
SemaphoreSlim(1,1)替代 lock,这个是 PLC 异步驱动的标配。
private readonly SemaphoreSlim _ioSem = new SemaphoreSlim(1,1);
public async Task<ModbusResult> ReadReg(ushort addr, ushort count)
{
await _ioSem.WaitAsync();
try
{
// send + receive
}
finally
{
_ioSem.Release();
}
}
2. 共享点位缓存、设备状态对象
多个采集线程写点位,MQTT / 上报线程同时读点位:
// 共享点位池
public class DevicePoint
{
public float Temp {get;set;}
public bool Alarm {get;set;}
}
- 场景 A:采集线程写、上报线程读,不加锁:会读到撕裂数据(比如浮点一半更新,读到非法值)
- 方案:
- 简单:访问这个 DevicePoint 全部包 lock;
- 追求性能:用
ConcurrentDictionary存点位,或者单生产者单消费者队列,采集写完丢队列,转发从队列拿; - 数值类型(int/bool)可以用
Interlocked;float、结构体不能 Interlocked,只能锁。
二、哪些场景【不需要 lock】
- 局部变量,每个 Task 自己的栈变量,没有共享,随便用;
- 只读配置(点位定义、从站地址、波特率,初始化之后不再修改);
- 每个设备独立 TCP 短连接:每次采集新建 Socket,用完就关,连接不共享,不需要锁;
- 无状态纯解析函数:输入 byte [],返回解析结果,不修改外部状态。
三、PLC 驱动开发的两个经典误区(很多 C# 上位机栽在这里)
误区 1:一把全局 lock 锁所有设备
比如所有 Modbus 从站共用同一个 lock,轮询串行排队。总线多了之后延迟爆炸,并发能力等于 0。 ✅ 正确:一个链路一把锁,不同串口 / 不同 TCP 连接之间互不阻塞。
误区 2:lock 包住的范围太大 / 太小
- 太小:只锁写,不锁读 → 读的时候刚好写一半,数据撕裂;
- 太大:锁里面塞日志、MQTT 上报、复杂业务逻辑 → 锁持有时间变长,排队堆积、超时变多。
最佳实践:锁里面只放【报文收发 + 应答接收校验】,解析、数据转发、上报放到锁外面。
四、顺带和前面的话题联动(C# ↔ Rust ↔ 仓颉)
- C# / 仓颉:你不写 lock /semaphore,编译器不报错,竞争 bug 藏在偶发场景(压力大、多轮询的时候才出现,最难查)
- Safe Rust:如果你想在多个任务同时持有可变的连接 / 点位对象,编译直接不让过,强迫你用 Mutex/Channel,从源头拦住。
五、给你一个选型速查表,写驱动直接对照
表格
| 场景 | 同步方案推荐 |
|---|---|
| 同步串口读写(老串口库,无 async) | lock(object) |
| async 串口 /async TCP 长连接 | SemaphoreSlim(1,1) |
| 共享点位字典,高频读写 | ConcurrentDictionary 或者锁 |
| 简单 int 计数、状态标记 | Interlocked |
| 多线程转发队列 | ConcurrentQueue |