标签: thread-safety

我有一个如下集合？

public ICollection<MyClass> Property { get; private set; }
...
Property = new List<MyClass>();

我希望在从DB中获取每个项目后添加MyClass项目.现在,每个数据库提取都在单独的后台线程中处理,并且它们同时运行.因此,DB调用的每个返回值都将面临.现在这可能会导致竞争条件,因为可能会在一个瞬间多次调用.PropertyMyClassProperty.Add()Property.Add()

所以我的问题是,List<>.Add()或者在ICollection<>.Add()内部执行的任何其他类处理任何竞争条件,还是需要明确处理？如果是这样呢？

假设我创建了一个类X的对象.当构造类X时,它会在一个无限循环的函数上创建一个分离的线程.当类X被销毁时,我想终止(或打破)这个分离的线程.这可能吗？有没有更好的方法来实现这一目标？

例如:

class X
{
public:
    X(){
        startThread();
    }
    virtual ~X(){

    }

    void myThread()
    {
        cout << "start of myThread()" << endl;

        int loop = 0;
        while(true)
        {
            //std::this_thread::sleep_for(std::chrono::seconds(5));
            ++loop;
            cout << "loop # " << loop << endl;
            if(this == NULL){
                break;
            }
        }

        cout << "end of myThread()" << endl;
    }

    void startThread()
    {
        std::thread example(&X::myThread, this);
        example.detach();
    }
};

我在这里提到了Jon Skeet的文章(http://csharpindepth.com/articles/general/singleton.aspx),第六个版本.

但是,我有一些私有变量,我想初始化一次,并被这个所谓的单例类中的方法使用.我在私有构造函数中初始化它们,但很快发现,在多线程场景(Task.Run)中调用方法时它们是null .

在调试时,我观察到私有构造函数在调用"实例"时没有调用两次(应该是),因此我假设我的私有变量在那个时间点不应该为空(成功的"实例"调用).

关于如何声明,初始化和使用这些变量的任何想法？

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazy =
        new Lazy<Singleton>(() => new Singleton());

    public static Singleton Instance { get { return lazy.Value; } }

    // my private variables
    private readonly string _plantCode;

    private Singleton()
    {
       var appSettings = ConfigurationManager.AppSettings;
       string _plantCode = appSettings["PlantCode"] ?? "Not Found";
    }

    public SomeMethod() 
    {
      var temp = _plantCode; // <== _plantCode becomes null here!
    }

}

我对C#的理解使我相信以下内容始终是线程安全的:

public static class Foo
{
    public static long Bar(long y)
    {
        long z = y;
        return z;
    }
}

但是,我被告知,因为长度大于32位处理器在一次操作中可以处理的长度,这不是线程安全的.

当我在静态java方法中使用静态属性时,此方法不再是线程保存.

在静态java方法中使用静态方法怎么样？这会弄乱我的价值观吗？

这里有一些例子:

我想这根本不是线程保存:

public static String staticText;
public static Integer staticNumber;

public static String doA(String input1, Integer input2){

    staticText = input1;
    staticNumber = input2;

    return staticText + staticNumber;
}

这将是线程保存:

public static String doB(String input1, Integer input2){
    return input1 + input2;
}

现在我的问题是,这个方法是什么:

public static String doC(String input1, Integer input2){
    return doB(input1, input2);
}

方法doC仍然是线程保存吗？我只是想确保在doC内调用doB的方法不会制动线程安全.

我无法真正获得使用swingworker的优势,而不仅仅是将繁重的任务放在一个(简单的)后台线程中.

这只是一个codesnippet,但显示了计算整数并将值放在JLabel中的任务.(这是在ActionPerformed中)

Thread t = new Thread() {
    public void run() {
        for (int i = 0; i < 2000000; i++) {
            counter++;
            label.setText(Integer.toString(counter));       
        }
    }
};

t.start();

我被告知使用抽象的SwingWorker类并覆盖doInBackground,process和done等方法,而不是这个简单的代码片段.

只需使用Thread更新标签,它就可以正常工作.为什么要创建一个扩展swingworker并实现抽象方法的新类？我现在只能把Swing-worker视为线程安全,那是答案吗？

有没有办法增加任务内部的int值？或者这是在任务中递增int的正确语法？示例代码:

public int erCount = 9;
static void Main(string[] args){
    Task.Factory.StartNew(() => { 
        ...do some task
        if(errorfound)
            erCount++;
    });
    Task.Wait();
    Console.Writeline(erCount.toString());
}

我似乎没有在线程内增加值.任何帮助都会很棒!

考虑Singleton:

public final class MySingleton {
    private static class Nested 
    {
        private static final MySingleton INSTANCE = new MySingleton();
    }

    private MySingleton() 
    {
        if (Nested.INSTANCE != null) 
        {
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static MySingleton getInstance() 
    {
        return Nested.INSTANCE;
    }
}

我没有放任何锁,但为什么这是Singleton问题的线程安全解决方案？

我想bool在一个线程中等待两个变量为真.他们在不同的地方改变.我可以在我的项目中使用boost,但不能在C++ 11中使用boost.我确实找到了有关如何使用互斥锁和条件变量的信息,但我不确定是否可以等待两个互斥锁.这是我的程序的一些伪代码.

bool job1_dataready, job2_dataready;

//t1:
void job1()
{
   //do stuff
   job1_dataready = true;
}

//t2:
void job2()
{
   //do stuff
   job2_dataready= true;
}

main()
{
 boost::thread t1(job1);
 boost::thread t1(job2);

 if(job1_dataready&& job2_dataready)
 {
    //do stuff with data from both jobs
 }

}

std::pair<Object, OtherObject*> currentData;

void OnCallback()
{
    Object object = getObject();
    OtherObject* otherObject = new OtherObject();
    currentData = std::make_pair(object, otherObject);
}

是make_pair原子？将make_pair字段从其返回值复制或移动到currentData？如果我有另一个线程访问该值currentData,那么访问它时是否有任何潜在currentData的价值不完整？

不幸的是,我没有在标准文档中看到任何相关信息make_pair.