C# 低级线程安全吗？解释

有人能解释一下我是否可以调用下面的类“线程安全”

据我所知，如果我们不破坏现有功能，我们可以称之为线程安全

例如：

public class BackgroundWorker
{
    private readonly IDictionary<string, RunningTask> _runningTasks = new ConcurrentDictionary<string, RunningTask>();

    /// <summary>
    /// Executes async job for the specified key, only one at a time.
    /// </summary>
    /// <param name="key"></param>
    public void Enqueue(string key)
    {
        if (_runningTasks.ContainsKey(key))
        {
            _runningTasks[key].Repeat = true;
            return;
        }

        _runningTasks[key] = new RunningTask();

        ExecuteTask(key);
    }

    private void ExecuteTask(string key)
    {
        Task.Run(() =>
        {
            // Do something

            if (_runningTasks[key].Repeat)
            {
                _runningTasks[key].Repeat = false;
                ExecuteTask(key);
                return;
            }

            _runningTasks.Remove(key);
        });
    }

    private class RunningTask
    {
        /// <summary>
        /// Flag to repeat a task after completion.
        /// </summary>
        public bool Repeat { get; set; }
    }
}

公共类后台工作程序
{
私有只读IDictionary_runningTasks=new ConcurrentDictionary（）；
/// 
///为指定的密钥执行异步作业，一次只能执行一个。
/// 
/// 
公共无效排队（字符串键）
{
if（_runningTasks.ContainsKey（键））
{
_runningTasks[key]。重复=true；
返回；
}
_runningTasks[键]=新建RunningTask（）；
执行任务（密钥）；
}
私有void ExecuteTask（字符串密钥）
{
Task.Run（（）=>
{
//做点什么
如果（_runningTasks[key]。重复）
{
_runningTasks[key]。Repeat=false；
执行任务（密钥）；
返回；
}
_运行任务。删除（键）；
});
}
私有类运行任务
{
/// 
///完成后重复任务的标志。
/// 
公共bool Repeat{get；set；}
}
}

我不这么认为，因为

\u runningTasks

是共享对象，而您的方法

排队

正在这个共享对象上写入。例如，当一个线程已经执行了行号y时，另一个线程可能会将行号x中的条件检查计算为true，这可能不是故意的

public void Enqueue(string key)
{
    if (_runningTasks.ContainsKey(key)) /*say line no : x */
    {
        _runningTasks[key].Repeat = true;
        return;
    }

    _runningTasks[key] = new RunningTask(); /*say line no:y*/

    ExecuteTask(key);
}

使用

ConcurrentDictionary

只会确保没有两个线程可以同时读/写字典

关于第二点：

据我所知，如果我们不是线程安全的，我们可以称之为线程安全的 打破现有功能

---

不，这不是线程安全的定义（可以说这是多线程环境中理想的结果之一），我建议阅读它的正式含义。

。线程安全与“破坏现有功能”无关，只是为了澄清：

ConcurrentDictionary

不能使类线程安全。但是，线程可能会在x行和runningTasks[key]行之间被抢占和其他线程可能会从字典中删除该任务。因此，第二行可能会抛出一个

KeyNotFoundException

。ConcurrentDictionary没有吗？