标签: thread-safety

我想要List<T>一个属性的实现,可以毫无疑问地使用线程安全.

像这样的东西:

private List<T> _list;

private List<T> MyT
{
    get { // return a copy of _list; }
    set { _list = value; }
}

看来我仍然需要返回一个集合(克隆)的集合,所以如果我们在某个地方迭代集合并同时设置集合,那么就不会引发异常.

如何实现线程安全的集合属性？

Random在多个线程之间共享一个类的实例是否有效？nextInt(int)特别是从多个线程调用？

是什么区别gcc -pthread和gcc -lpthread它在编译多线程程序中使用？

是SecureRandom线程安全的？也就是说,在初始化之后,可以访问依赖的下一个随机数是线程安全的吗？检查源代码似乎表明它是,并且这个错误报告似乎表明它缺乏文档作为线程安全是一个javadoc问题.有人确认它实际上是线程安全的吗？

在单独的线程上运行代码的最佳方法是什么？是吗:

[NSThread detachNewThreadSelector: @selector(doStuff) toTarget:self withObject:NULL];

要么:

    NSOperationQueue *queue = [NSOperationQueue new];
NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self
                                                                        selector:@selector(doStuff:)
                                                                          object:nil;
[queue addOperation:operation];
[operation release];
[queue release];

我一直在做第二种方式,但我读过的Wesley Cookbook使用的是第一种方式.

class ThreadSafeClass extends Thread
{
     private static int count = 0;

     public synchronized static void increment()
     {
         count++;
     }

     public synchronized void decrement()
     {
         count--;
     }
}

谁能解释为什么上面的类不是线程安全的？

我有一个持有字典的班级

class OrderBook:
    orders = {'Restaurant1': None,
              'Restaurant2': None,
              'Restaurant3': None,
              'Restaurant4': None}

    @staticmethod
    def addOrder(restaurant_name, orders):
        OrderBook.orders[restaurant_name] = orders

我正在运行调用该方法的4个线程(每个餐厅一个)OrderBook.addOrder.这是每个线程运行的函数:

def addOrders(restaurant_name):

    #creates orders
    ...

    OrderBook.addOrder(restaurant_name, orders)

这是安全的,还是我必须在打电话前使用锁addOrder？

从Rails 4开始,默认情况下,所有内容都必须在线程环境中运行.这意味着所有我们写的代码和 所有我们使用需要是宝石threadsafe

所以,我对此几乎没有问题:

1. 在ruby/rails中什么不是线程安全的？Vs什么是ruby/rails的线程安全？
2. 是否有宝石的列表被称为是线程安全的,反之亦然？
3. 有没有线程安全示例的常见代码模式列表@result ||= some_method？
4. ruby lang核心中的数据结构是否是诸如Hash线程安全的？
5. 在核磁共振成像上,其中一个GVL/GIL表示一次只能运行一个红宝石线程,除了IO线程安全变化对我们有影响吗？

我正在审查一些顾问编写的代码,虽然已经弹出了数十个红旗,但我无法围绕以下片段进行讨论:

private void foo()
{
    if (InvokeRequired)
    {
        lock (new object())
        {
            if (m_bar!= null)
                Invoke(new fooDelegate(foo), new object[] { });
        }
    }
    else
    {
        if(OnBazChanged != null)
            OnBazChanged();
    }
}

什么是锁(新对象())在这做什么？应该没有任何影响,因为它始终锁定在另一个对象上,但这种锁定在整个代码中都是持久的,即使在非复制粘贴的部分也是如此.这是C#语言中的一些特殊情况,编译成我不知道的东西,还是程序员只是采用了一些恰好在前一段时间工作的货物崇拜？

我正在阅读Java中的多线程,我遇到了这个问题

局部变量在Java中是线程安全的.

从那时起,我一直在思考如何/为什么局部变量是线程安全的.

有人可以让我知道.