(IIC,基本上,这归结为malloc是否是线程安全的问题.)

考虑示例代码：

#define _GNU_SOURCE
#include <stdio.h>

#include "getValue.h"

char * getValue(int key) {
  char * value;
  asprintf(&value,"%d",key); // Todo: No error handling!
  // If memory allocation wasn't possible,or some other error occurs,these  functions  will
  // return -1,and the contents of strp is undefined.
  return value;
}

在这里,我不触及任何全局变量.如果我的getValue在并发线程中被调用怎么办？没有坏事会发生,他们会吗？

asprintf

Function: int asprintf (char **ptr,const char *template,…)
Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem

关于’locale’exception,特别是：

Functions annotated with locale as an MT-Safety issue read from the locale object without any form of synchronization. Functions annotated with locale called concurrently with locale changes may behave in ways that do not correspond to any of the locales active during their execution,but an unpredictable mix thereof.

这些类型的函数被称为“conditionally”多线程安全,因为在某些情况下,它们结果并非如此,因此程序员需要处理这些问题.

RestSharp似乎是显而易见的选择.然而,经过一番挖掘,我发现了this issue.

我无法在RestSharp谷歌组和GitHub上找到有关此问题的任何更新的证据.

在最后一次发布之前报告了这个问题,但我再也无法确定问题是否已得到修复.

有谁知道问题是否已修复？

https://github.com/restsharp/RestSharp/issues/951

class Test {
    public static Queue<int> queue = new Queue<int>(10000);

    Thread putIntThread;
    Thread takeIntThread;

    public test() {
        for(int i = 0; i < 5000; ++i) {
            queue.Enqueue(0);
        }
        putIntThread = new Thread(this.PutInt);
        takeIntThread = new Thread(this.TakeInt);
        putIntThread.Start();
        takeIntThread.Start();
    }

    void PutInt() {
        while(true)
        {
            if(queue.Count < 10000) {//no need to lock here as only itself can change this condition
                queue.Enqueue(0);
            }
        }
    }

    void TakeInt() {
        while(true) {
            if(queue.Count > 0) {//no need to lock here as only itself can change this condition
                queue.Dequeue();
            }
        }
    }

}

编辑：我必须使用.NET 3.5

Public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

A Queue<T> can support multiple readers concurrently,as long as the collection is not modified. Even so,enumerating through a collection is intrinsically not a thread-safe procedure. To guarantee thread safety during enumeration,you can lock the collection during the entire enumeration. To allow the collection to be accessed by multiple threads for reading and writing,you must implement your own synchronization.

重读你的问题,你似乎对这个短语“这种类型的静态成员”感到困惑 – 这不是说“静态队列”,因为没有这样的事情.一个对象不是静态的 – 一个成员是.当谈到静态成员时,它谈论的是Encoding.GetEncoding(Queue< T>实际上没有任何静态成员).实例成员是Enqueue和Dequeue – 与类型实例相关的成员,而不是类型本身.

因此,您需要为每个操作使用锁定,或者如果您使用的是.NET 4,请使用ConcurrentQueue<T>.