Rust和C#,仓颉,多线程访问同一个对象区别加锁

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】

  1. 局部变量,每个 Task 自己的栈变量,没有共享,随便用;
  2. 只读配置(点位定义、从站地址、波特率,初始化之后不再修改);
  3. 每个设备独立 TCP 短连接:每次采集新建 Socket,用完就关,连接不共享,不需要锁;
  4. 无状态纯解析函数:输入 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
正文完
 0