标签: thread-safety

class Unit {
    private readonly string name;
    private readonly double scale;

    public Unit(string name, double scale) {
        this.name = name;
        this.scale = scale,
    }

    public string Name { get { return name; } }
    public string Scale { get { return scale; } }

    private static Unit gram = new Unit("Gram", 1.0);

    public Unit Gram { get { return gram; } }
}

多个线程可以访问Unit.Gram.为什么多个线程同时读取都可以Unit.Gram.Title？

我担心的是他们指的是相同的内存位置.一个线程开始读取该内存,那么它是不是"被锁定"了呢？.NET是否处理下面这个关键部分的同步？或者我认为同步阅读需要同步？

我正在建立一个网站,我想在标准的MyISAM表中增加一个计数器.

简化示例:

UPDATE votes SET num = num + 1;

如果多个连接正在执行相同的查询,这会导致问题,还是MySQL会处理它并锁定表或某些东西以确保没有冲突？

文档ConcurrentDictionary没有明确的状态,所以我想我们不能指望委托valueFactory并updateValueFactory让它们的执行同步(分别来自GetOrAdd()和AddOrUpdate()操作).

因此,我认为我们无法在其中实现需要并发控制的资源,而无需手动实现我们自己的并发控制,可能只是使用[MethodImpl(MethodImplOptions.Synchronized)]代理.

我对吗？或者ConcurrentDictionary是线程安全的事实,我们可以预期对这些代理的调用会自动同步(线程安全)？

我有一个问题boost::shared_ptr<T>.

有很多线程.

using namespace boost;

class CResource
{
  // xxxxxx
}

class CResourceBase
{
public:
   void SetResource(shared_ptr<CResource> res)
   {
     m_Res = res;
   }

   shared_ptr<CResource> GetResource()
   {
      return m_Res;
   }
private:
   shared_ptr<CResource> m_Res;
}

CResourceBase base;

//----------------------------------------------
// Thread_A:
    while (true)
    {
       //...
       shared_ptr<CResource> nowResource = base.GetResource();
       nowResource.doSomeThing();
       //...
    }

// Thread_B:
    shared_ptr<CResource> nowResource;
    base.SetResource(nowResource);
    //...

Q1

如果Thread_A不关心nowResource是最新的,那么这部分代码会有问题吗？

我的意思是当Thread_B没有SetResource()完全,Thread_A得到一个错误的智能点GetResource()？

Q2

线程安全是什么意思？

如果我不关心资源是否是最新的,那么shared_ptr<CResource> nowResource当程序nowResource被释放时会崩溃程序还是会破坏问题 …

就像是"修改"运营商+=,|=,&=等原子？

我知道++是原子的(如果你x++;同时在两个不同的线程中执行),你总是会x增加2,而不是x=x+1关闭优化.)

我想知道是否variable |= constant,以及喜欢是线程安全的还是我必须使用互斥锁来保护它们？

(...或者它是否依赖于CPU？在这种情况下,它在ARM上是怎么回事？)

在C++ 11中,有许多新的随机数生成器引擎和分发函数.它们是否安全？如果您在多个线程之间共享一个随机分布和引擎,它是否安全并且您是否仍会收到随机数？我正在寻找的场景是这样的,

void foo() {
    std::mt19937_64 engine(static_cast<uint64_t> (system_clock::to_time_t(system_clock::now())));
    std::uniform_real_distribution<double> zeroToOne(0.0, 1.0);
#pragma omp parallel for
    for (int i = 0; i < 1000; i++) {
        double a = zeroToOne(engine);
    }
}

使用OpenMP或

void foo() {
    std::mt19937_64 engine(static_cast<uint64_t> (system_clock::to_time_t(system_clock::now())));
    std::uniform_real_distribution<double> zeroToOne(0.0, 1.0);
    dispatch_apply(1000, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^(size_t i) {
        double a = zeroToOne(engine);
    });
}

使用libdispatch.

在Android中,有没有办法获得静态方式的应用程序的上下文？例如,从后台线程中检索它.

谢谢

Redis如何处理Redis中更新相同数据结构的多个线程(来自不同客户端)？这种用例的推荐最佳做法是什么？

可能重复:
Java同步

我正在读" 初学Android游戏 "一书.

它使用synchronized()了很多,但我真的不明白它的作用.我很久没有使用Java了,我不确定我是否使用过多线程.

在它使用的Canvas示例中synchronized(this).但是在OpenGL ES示例中,它创建了一个被调用的Object stateChanged然后使用synchronized(stateChanged).当游戏状态改变时,它会调用stateChanged.wait()然后stateChanged.notifyAll();

一些代码:

    Object stateChanged = new Object();

    //The onPause() looks like this:
    public void onPause()
        {
            synchronized(stateChanged)
            {
                if(isFinishing())
                    state = GLGameState.Finished;
                else
                    state = GLGameState.Paused;

                while(true)
                {
                    try
                    {
                        stateChanged.wait();
                        break;
                    } catch(InterruptedException e)
                    {
                    }
                }
            }
        }
//The onDrawSurface looks like this:
public void onDrawFrame(GL10 gl)
    {
        GLGameState state = null;
        synchronized(stateChanged)
        {
            state = this.state;
        }

        if(state == …

让我说我有

std::tuple<T0, T1, T2> my_tuple{x0, x1, x2};

其中T0,T1和T2是值类型(即没有混叠是可能的).

只要每个线程访问不同的元素,访问my_tuple元素并从多个线程同时改变它们是否安全std::get？

例:

template <typename T>
void process(T& x) { /* mutate `x` */ }

// ...

std::thread{[&]{ process(std::get<0>(my_tuple)); }}.detach();
std::thread{[&]{ process(std::get<1>(my_tuple)); }}.detach();
std::thread{[&]{ process(std::get<2>(my_tuple)); }}.detach();

本能地,我会说它是安全的,my_tuple可以被认为是struct { T0 x0; T1 x1; T2 x2; };......但它是否由标准保证？