标签: atomic

一般来说,当我们从多个进程附加到UNIX中的文件时,我们可以理所当然地认为什么？是否有可能丢失数据(一个进程会覆盖其他进程)？数据是否可能被破坏？(例如,每个进程在每个追加到日志文件时附加一行,是否有可能两行被破坏？)如果追加在上述意义上不是原子的,那么确保互斥的最佳方法是什么？

原子操作的成本是什么(比较和交换或原子添加/减少中的任何一个)？它消耗了多少周期？它会暂停SMP或NUMA上的其他处理器,还是会阻止内存访问？它会在无序CPU中刷新重新排序缓冲区吗？

缓存有什么影响？

我对现代流行的CPU感兴趣:x86,x86_64,PowerPC,SPARC,Itanium.

如果有办法防止两个或多个用户同时修改同一数据库条目？

向执行第二次提交/保存操作的用户显示错误消息是可以接受的,但不应以静默方式覆盖数据.

我认为锁定条目不是一个选项,因为用户可能会使用"后退"按钮或只是关闭他的浏览器,永远保持锁定.

bool compare_exchange_weak (T& expected, T val, ..);

compare_exchange_weak()是C++ 11中提供的比较交换原语之一.它在某种意义上很弱,即使对象的值等于它也会返回false expected.这是由于某些平台上的虚假故障导致一系列指令(而不是x86上的指令)用于实现它.在这样的平台上,上下文切换,由另一个线程重新加载相同的地址(或高速缓存行)等可能使原语失败.这是spurious因为它不是expected操作失败的对象(不等于)的值.相反,这是一种时间问题.

但让我感到困惑的是C++ 11标准(ISO/IEC 14882)中所说的,

29.6.5 ..虚假失败的后果是几乎所有弱比较和交换的使用都将处于循环中.

为什么几乎所有用途都必须处于循环中？这是否意味着我们会因为虚假失败而失败？如果是这样的话,为什么我们compare_exchange_weak()自己打扰使用并编写循环？我们可以使用compare_exchange_strong()我认为应该摆脱我们的虚假失败.有哪些常见用例compare_exchange_weak()？

另一个问题有关.安东尼在他的书"C++ Concurrency In Action"中说,

//Because compare_exchange_weak() can fail spuriously, it must typically
//be used in a loop:

bool expected=false;
extern atomic<bool> b; // set somewhere else
while(!b.compare_exchange_weak(expected,true) && !expected);

//In this case, you keep looping as long as expected is still false,
//indicating that the compare_exchange_weak() …

从OCP Java SE 6程序员实践考试的第291页开始,问题25:

public class Stone implements Runnable {
    static int id = 1;

    public void run() {
        id = 1 - id;
        if (id == 0) 
            pick(); 
        else 
            release();
    }

    private static synchronized void pick() {
        System.out.print("P ");
        System.out.print("Q ");
    }

    private synchronized void release() {
        System.out.print("R ");
        System.out.print("S ");
    }

    public static void main(String[] args) {
        Stone st = new Stone();
        new Thread(st).start();
        new Thread(st).start();
    }
}

其中一个答案是:

输出可能是 P Q P Q

我把这个答案标记为正确.我的推理:

1. 我们开始两个线程.
2. 第一个进入run() …

从我从Herb Sutter和其他人那里读到的内容,您会认为volatile并发编程是完全正交的概念,至少就C/C++而言.

但是,在GCC 实现中,所有std::atomic的成员函数都有volatile限定符.安东尼威廉姆斯的实施也是如此std::atomic.

那么什么是交易,我的atomic<>变量需要volatile与否？

既然C++ 11有多线程,我想知道在不使用互斥锁的情况下实现延迟初始化单例的正确方法是什么(出于性能原因).我想出了这个,但是我并不擅长编写无锁代码,所以我正在寻找更好的解决方案.

// ConsoleApplication1.cpp : Defines the entry point for the console application.
//
# include <atomic>
# include <thread>
# include <string>
# include <iostream>
using namespace std;
class Singleton
{

public:
    Singleton()
    {
    }
static  bool isInitialized()
    {
        return (flag==2);
    }
static  bool initizalize(const string& name_)
    {
        if (flag==2)
            return false;// already initialized
        if (flag==1)
            return false;//somebody else is initializing
        if (flag==0)
        {
            int exp=0;
            int desr=1;
            //bool atomic_compare_exchange_strong(std::atomic<T>* obj, T* exp, T desr)
            bool willInitialize=std::atomic_compare_exchange_strong(&flag, &exp, desr); …

如果数据结构中包含多个元素,则它的原子版本不能(始终)无锁.我被告知这对于较大的类型是正确的,因为CPU不能在不使用某种锁的情况下以原子方式更改数据.

例如:

#include <iostream>
#include <atomic>

struct foo {
    double a;
    double b;
};

std::atomic<foo> var;

int main()
{
    std::cout << var.is_lock_free() << std::endl;
    std::cout << sizeof(foo) << std::endl;
    std::cout << sizeof(var) << std::endl;
}

输出(Linux/gcc)是:

0
16
16

由于原子和foo大小相同,我不认为锁存储在原子中.

我的问题是:
如果一个原子变量使用一个锁,它存储在哪里,这对该变量的多个实例意味着什么？

任何人都可以用简单的英语解释什么是std :: memory_order,以及如何将它们与std :: atomic <>一起使用？

我在这里找到了参考文献和一些例子,但根本不了解. http://en.cppreference.com/w/cpp/atomic/memory_order

谢谢.

C++ 11标准定义了一个内存模型(1.7,1.10),它包含内存排序,大致是"顺序一致","获取","消费","释放"和"放松".同样粗略地说,程序只有在没有竞争的情况下才是正确的,如果所有动作都可以按照某个动作的顺序放在另一个动作之前,则会发生这种情况.动作 X发生的方式 - 在动作Y 之前是X在Y之前(在一个线程内)被排序,或者X在线程间 - 在Y之前发生.其中,后者的条件是在何时

• X与Y同步,或
• X在Y之前是依赖排序的.

当X是在某个原子变量上具有"释放"排序的原子存储时发生同步,并且Y是在同一变量上具有"获取"排序的原子加载.作为依赖项,订购前发生了类似的情况,其中Ÿ是负载"消费"排序(和合适的内存访问).的概念下同步,与延伸的之前发生关系传递性跨越的行动被测序,之前彼此线程内,但被相关性排序,之前只有通过严格的子集传递性扩展测序,之前叫依赖于大规模规则的依赖性,特别是可以被中断std::kill_dependency.

那么,"依赖性排序"概念的目的是什么？与简单的排序 - 先前/同步 -排序相比,它提供了什么优势？由于它的规则更严格,我认为可以更有效地实施.

你能举一个程序的例子,从发布/获取到发布/消费的转换是正确的,并提供一个非平凡的优势吗？何时能std::kill_dependency提供改进？高级别参数会很好,但硬件特定差异的奖励点.