标签: thread-safety

我无法理解这个错误的底部,因为当附加调试器时,它似乎不会发生.下面是代码.

这是Windows服务中的WCF服务器.每当存在数据事件时,服务就会调用NotifySubscribers方法(以随机间隔,但不常见 - 每天约800次).

当Windows窗体客户端订阅时,订户ID将添加到订阅者字典中,当客户端取消订阅时,将从字典中删除它.客户端取消订阅时(或之后)发生错误.看来,下次调用NotifySubscribers()方法时,foreach()循环失败并显示主题行中的错误.该方法将错误写入应用程序日志,如下面的代码所示.当附加调试器并且客户端取消订阅时,代码执行正常.

你看到这段代码有问题吗？我是否需要使字典线程安全？

[ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]
public class SubscriptionServer : ISubscriptionServer
{
    private static IDictionary<Guid, Subscriber> subscribers;

    public SubscriptionServer()
    {            
        subscribers = new Dictionary<Guid, Subscriber>();
    }

    public void NotifySubscribers(DataRecord sr)
    {
        foreach(Subscriber s in subscribers.Values)
        {
            try
            {
                s.Callback.SignalData(sr);
            }
            catch (Exception e)
            {
                DCS.WriteToApplicationLog(e.Message, 
                  System.Diagnostics.EventLogEntryType.Error);

                UnsubscribeEvent(s.ClientId);
            }
        }
    }


    public Guid SubscribeEvent(string clientDescription)
    {
        Subscriber subscriber = new Subscriber();
        subscriber.Callback = OperationContext.Current.
                GetCallbackChannel<IDCSCallback>();

        subscribers.Add(subscriber.ClientId, subscriber);

        return subscriber.ClientId;
    }


    public void UnsubscribeEvent(Guid clientId)
    {
        try
        {
            subscribers.Remove(clientId);
        }
        catch(Exception …

我看到PHP的不同二进制文件,如非线程或线程安全？这是什么意思？这些套餐有什么区别？

我看到,对于使用非线程安全的对象,我们用这样的锁包装代码:

private static readonly Object obj = new Object();

lock (obj)
{
    // thread unsafe code
}

那么当多个线程访问相同的代码时会发生什么(让我们假设它在ASP.NET Web应用程序中运行).他们排队了吗？如果是这样,他们会等多久？

使用锁会对性能产生什么影响？

在RxJava中有5种不同的调度程序可供选择:

1. immediate():创建并返回一个在当前线程上立即执行工作的Scheduler.

2. trampoline():创建并返回一个调度程序,该调度程序对当前工作完成后要执行的当前线程进行排队.

3. newThread():创建并返回一个Scheduler,为每个工作单元创建一个新的Thread.

4. computation():创建并返回用于计算工作的Scheduler.这可以用于事件循环,处理回调和其他计算工作.不要在此调度程序上执行IO绑定的工作.使用调度程序.io()代替.

5. io():创建并返回一个用于IO绑定工作的Scheduler.该实现由Executor线程池支持,该线程池将根据需要增长.这可用于异步执行阻塞IO.不要在此调度程序上执行计算工作.使用调度程序.计算()而不是.

问题:

前3个调度程序非常自我解释; 但是,我对计算和io有点困惑.

1. 究竟什么是"IO限制工作"？它用于处理streams(java.io)和files(java.nio.files)吗？它用于数据库查询吗？它是用于下载文件还是访问REST API？
2. 如何计算()从不同newThread() ？是每次所有的calculate()调用都在单个(后台)线程而不是新的(后台)线程上吗？
3. 为什么在进行IO工作时调用calculate()会很糟糕？
4. 为什么在进行计算工作时调用io()会很糟糕？

请告诉代码示例为什么SimpleDateFormat不是线程安全的.这堂课有什么问题？ SimpleDateFormat的格式功能有问题吗？请给出一个在课堂上演示此错误的代码.

FastDateFormat是线程安全的.为什么？b/w SimpleDateFormat和FastDateFormat有什么区别？

请用解释此问题的代码解释一下？

我知道这是一个经常被问到的问题,但由于有很多变种,我想重新陈述它,并希望有一个反映当前状态的答案.就像是

Logger& g_logger() {
    static Logger lg;
    return lg;
}

变量lg的构造函数是否保证只运行一次？

我从以前的答案中知道,在C++ 03中,这不是; 在C++ 0x草案中,这是强制执行的.但我想要一个更明确的答案

1. 在C++ 11标准(非草稿)中,线程安全的初始化行为是否已完成？
2. 如果以上是肯定的,那么在当前最新版本的热门编译器中,即gcc 4.7,vc 2011和clang 3.0,它们是否正确实施？

大多数 的 的 时代,再进入的定义转引自维基百科:

如果计算机程序或例程在其先前的调用完成之前可以被安全地再次调用(即可以同时安全地执行),则将其描述为可重入的 .可重入,计算机程序或例程:

1. 必须不保留静态(或全局)非常量数据.
2. 不得将地址返回到静态(或全局)非常量数据.
3. 必须仅对调用者提供给它的数据有效.
4. 不能依赖于锁定单例资源.
5. 不得修改自己的代码(除非在自己独特的线程存储中执行)
6. 不得调用不可重入的计算机程序或例程.

如何安全地定义？

如果一个程序可以安全地同时执行,它是否总是意味着它是可重入的？

在检查我的代码是否具有重入功能时,我应该记住的六点之间的共同点是什么？

也,

1. 所有递归函数都是可重入的吗？
2. 所有线程安全功能都是可重入的吗？
3. 所有递归和线程安全函数都是可重入的吗？

在写这个问题的时候,有一件事情浮现在脑海中:像重入和线程安全这样的术语是否完全绝对,即他们是否有固定的具体定义？因为,如果他们不是,这个问题不是很有意义.

我已经痛苦地意识到需要在事件驱动的GUI代码中编写以下代码模式的频率,其中

private void DoGUISwitch() {
    // cruisin for a bruisin' through exception city
    object1.Visible = true;
    object2.Visible = false;
}

变为:

private void DoGUISwitch() {
    if (object1.InvokeRequired) {
        object1.Invoke(new MethodInvoker(() => { DoGUISwitch(); }));
    } else {
        object1.Visible = true;
        object2.Visible = false;
    }
}

这是C#中的一个尴尬模式,无论是记忆还是打字.有没有人提出某种捷径或构造,在一定程度上自动化？如果有一种方法可以将函数附加到执行此检查的对象,而不必经历所有这些额外的工作,如object1.InvokeIfNecessary.visible = true类型快捷方式,那就太酷了.

上一页答案已经讨论的只是打电话的invoke()每次不切实际,甚则调用()语法既效率低下,仍然尴尬应对.

那么,有没有人想出任何捷径？

如果我在同一个类中有2个同步方法,但每个方法访问不同的变量,那么2个线程可以同时访问这两个方法吗？锁是否发生在对象上,或者它是否与synchronized方法中的变量一样具体？

例:

class X {

    private int a;
    private int b;

    public synchronized void addA(){
        a++;
    }

    public synchronized void addB(){
        b++;
    }

}

2个线程可以同时访问同一个X类实例x.addA()x.addB()吗？

我需要一个队列,多个线程可以放入东西,多个线程可以读取.

Python至少有两个队列类,Queue.Queue和collections.deque,前者似乎在内部使用后者.两者都声称在文档中是线程安全的.

但是,队列文档还指出:

collections.deque是无界队列的替代实现,具有快速原子append()和popleft()操作,不需要锁定.

我想我不太沉思:这是否意味着deque毕竟不是完全线程安全的？

如果是,我可能不完全理解这两个类之间的区别.我可以看到Queue添加了阻止功能.另一方面,它失去了一些deque功能,如支持运营商.

直接访问内部deque对象是

x在队列().deque

线程安全的？

另外,为什么当deque已经是线程安全的时候,Queue会使用互斥锁进行操作？