这是线程安全的吗？ [英] This is Thread-Safe right?

问题描述

只是检查... _count 正在访问的安全，对吧？

这两种方法都是由多个访问。螺纹

 私人诠释_count; 
 
公共无效CheckForWork（）{
如果（_count> =最大值）的回报; 
 Interlocked.Increment（REF _count）; 
任务T = Task.Run（（）=>工作（））; 
 t.ContinueWith（CompletedWorkHandler）; 
} 
 
公共无效CompletedWorkHandler（任务completedTask）{
 Interlocked.Decrement（REF _count）; 
 //处理错误，等等... 
} 
  

解决方案

没有，如果（_count> =最大值）的回报。不是线程安全的。

编辑：你不得不围绕看得太重，这应该那么在逻辑上与增量进行分组锁定，所以我喜欢重写

 私人诠释_count; 
 
私人只读对象_locker_ =新的对象（）; 
 
公共无效CheckForWork（）{
锁（_locker_）
 {
如果（_count> =最大值）
的回报; 
 _count ++; 
} 
 Task.Run（（）=>工作（））; 
} 
 
公共无效CompletedWorkHandler（）{
锁（_locker_）
 {
 _count--; 
} 
：
} 
  

Just checking... _count is being accessed safely, right?

Both methods are accessed by multiple threads.

private int _count;

public void CheckForWork() {
    if (_count >= MAXIMUM) return;
    Interlocked.Increment(ref _count);
    Task t = Task.Run(() => Work());
    t.ContinueWith(CompletedWorkHandler);
}

public void CompletedWorkHandler(Task completedTask) {
    Interlocked.Decrement(ref _count);
    // Handle errors, etc...
}

解决方案

No, if (_count >= MAXIMUM) return; is not thread safe.

edit: You'd have to lock around the read too, which should then logically be grouped with the increment, so I'd rewrite like

private int _count;

private readonly Object _locker_ = new Object();

public void CheckForWork() {
    lock(_locker_)
    {
        if (_count >= MAXIMUM)
            return;
        _count++;
    }
    Task.Run(() => Work());
}

public void CompletedWorkHandler() {
    lock(_locker_)
    {
        _count--;
    }
    ...
}

这篇关于这是线程安全的吗？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！