标签: atomic

假设对齐的指针加载和存储在目标平台上自然是原子的,这有什么区别:

// Case 1: Dumb pointer, manual fence
int* ptr;
// ...
std::atomic_thread_fence(std::memory_order_release);
ptr = new int(-4);

这个:

// Case 2: atomic var, automatic fence
std::atomic<int*> ptr;
// ...
ptr.store(new int(-4), std::memory_order_release);

还有这个:

// Case 3: atomic var, manual fence
std::atomic<int*> ptr;
// ...
std::atomic_thread_fence(std::memory_order_release);
ptr.store(new int(-4), std::memory_order_relaxed);

我的印象是它们都是等价的,但是Relacy在第一种情况下(仅)检测到数据竞争:

struct test_relacy_behaviour : public rl::test_suite<test_relacy_behaviour, 2>
{
    rl::var<std::string*> ptr;
    rl::var<int> data;

    void before()
    {
        ptr($) = nullptr;
        rl::atomic_thread_fence(rl::memory_order_seq_cst);
    }

    void thread(unsigned int id)
    {
        if (id == 0) { …

我读到某处(无法找到页面)锁定免费数据结构对于"某些工作负载"更有效,这似乎意味着有时它们实际上更慢或者在某些情况下它们的增益可能为零.对锁定指令进行大约100次循环命中来执行原子操作听起来要快得多,而不是等待调度程序将进程重新唤醒,所以对于我来说,在什么情况下无锁数据结构不是很明显比旧式的互斥体更不可取.如果锁定在99%的时间内可用且进程无需进入休眠状态,那么互斥锁会更快吗？假设有合适的无锁数据结构,是否有一个很好的经验法则可以知道哪条路可用？

什么是自动生成的getter和setter看起来像以下属性值？

... in .h
@interface MyClass : NSObject {
@private
    NSString *_value;
}

@property(retain) NSString *value;

... in .m
@synthesize value = _value;

如果我改变属性怎么办？

@property(retain, readonly) NSString *value;

特别是我对故事的原子部分感兴趣,加上保留,如果可能的话,详细的代码将更清楚地说明幕后发生了什么.

想象一下,一个web应用程序存储一些数据资源,其中一些id存储每个数据的三个附件(例如pdf).

URL方案是

data/{id}/attachment1
data/{id}/attachment2
data/{id}/attachment3

存在用于在服务器端实现CRUD操作的GET/PUT/DELETE操作的附件的RESTful API.

让id为123,我想执行一个操作

• attachment1被新附件替换(例如GET file/123/attachment1返回新附件)
• attachment2被删除(这样GET file/123/attachment2返回404)
• attachment3保持不变.

该更新应该是原子 -由服务器或什么都没有进行完整的更新.

运用简单PUT file/123/attachment1而DELETE file/123/attachment2不是原子,因为客户可以在PUT之后崩溃,并且服务器有没有暗示他应该在这种情况下,做了回退.

那么如何以RESTful方式实现操作呢？

我想过两个解决方案,但它们似乎都不是100%RESTful:

• 使用PATCH(可能是PUT,但PATCH更好地反映了部分更新的语义)和数据/ 123上的multipart/form-data:multipart/form-data是一个由新的"application/pdf"组成的实体序列使用字段"attachment1"和表示删除attachment2的空值的东西.

虽然这确保了原子性,但我怀疑这是RESTful,因为我使用不同的参数列表重载PATCH方法,这违反了统一接口约束.

• 使用表示事务的资源.我可以将数据id 123发布到事务URL,该事务URL将创建表示存储在服务器上的数据资源的当前状态的副本的事务资源,例如事务/数据/ 123.现在,我可以在此临时资源(例如DELETE transaction/data/123/attachment2)的附件上调用PUT和DELETE,并通过事务/ data/123上的PUT将此版本资源的提交传达给服务器.这确保了原子性,同时必须实现额外的服务器端逻辑来处理更改相同资源的多个客户端以及从未提交的崩溃客户端.

虽然这似乎与REST一致,但似乎违反了无国籍的约束.事务资源的状态不是服务状态而是应用程序状态,因为每个事务资源都与单个客户端相关联.

我有点被困在这里,所以任何想法都会有所帮助,谢谢!

我理解的意思atomic是在原子和非原子属性之间有什么区别？,但我想知道的是:

问:除了性能问题之外,在所有地方使用原子属性是否有任何副作用？

似乎答案是否定的,因为现在iPhone的性能相当快.那么为什么这么多人还在使用non-atomic呢？

即使atomic不保证线程安全,但它仍然比没有好,对吧？

http://gcc.gnu.org/onlinedocs/gcc-4.4.2/gcc/Atomic-Builtins.html

我相信以下代码会原子地增加var的值.

volatile int var = 0;
__sync_fetch_and_add( &var, 1 )

我将上述代码理解为以下逻辑:

1. 加载变量var的地址
2. 将数字1写入变量var原子 - 通过寄存器/缓存,以某种方式

但是,我怀疑以下是否也是原子的

volatile int var = 0;
volatile int num = 1;
__sync_fetch_and_add( &var, num )

因为它可能被解释为

1. 加载变量var的地址
2. 将变量num的值加载到寄存器中
3. 将值写入变量var.

执行#2之后,但在#3之前,CPU /线程被中断,另一个CPU /线程更新变量num的值.

换句话说,当使用gcc的_ sync*()时,我可以使用变量而不是常量作为第二个参数吗？

它不会破坏原子性吗？

我想以线程安全的方式为名为order的类生成标识符.下面的代码无法编译.我知道原子类型没有复制构造函数,我认为这解释了为什么这段代码不起作用.有没有人知道实际让这段代码工作的方法？我还在学习,所以如果我在错误的轨道上也请告诉我(如果是的话,如果你能指出我的替代方法,我将不胜感激).谢谢!

#include <atomic>
#include <iostream>

class order {
public: 
    order() { id=c.fetch_add(1); }
    int id;
private:
    static std::atomic<int> c;
};

std::atomic<int> order::c = std::atomic<int>(0);

int main() {
    order *o1 = new order();
    order *o2 = new order();
    std::cout << o1->id << std::endl; // Expect 0
    std::cout << o2->id << std::endl; // Expect 1
}

编译以上结果会出现以下错误:

order.cpp:45:51: error: use of deleted function 
        ‘std::atomic<int>::atomic(const std::atomic<int>&)’
In file included from order.cpp:3:0:
/usr/include/c++/4.7/atomic:594:7: error: declared here

就实际的低级原子指令和内存栅栏而言(我假设它们已被使用),您如何实现STM？

对我来说神秘的部分是,给定一些任意代码块,您需要一种方法可以在之后返回并确定每个步骤中使用的值是否有效.你是怎么做到的,你如何有效地做到这一点？这也似乎表明,就像任何其他"锁定"解决方案一样,您希望保持关键部分尽可能小(以减少冲突的可能性),我是对的吗？

此外,STM可以简单地检测"在执行计算时进入该区域的另一个线程,因此计算无效"或者它是否可以实际检测是否使用了破坏的值(因此运气时有时两个线程可以同时执行相同的临界区需要回滚)？

1. 大小int为32位和long/ double或64位.这些尺寸是否保持相同
   1. 32/64位JVM
   2. 32/64位处理器
2. 如果是,那么64位处理器/ JVM上的操作是long/ double原子的？

在甲骨文的Java教程说:

读取和写入对于引用变量和大多数原始变量(除long和double之外的所有类型)都是原子的.

这个陈述与jvm/processor架构有什么关系吗？有人可以解释一下.

3.如果我使用64位jvm和处理器,最后我将能够读/写双/长原子

在C和C++的标准术语,短语" 原子对象 "是指" 物体的原子类型, "不是吗？

没有标准会明确定义每个双字短语,因此没有错误的C和C++标准,因为省​​略了这个短语的明确定义.然而,当我读到C++ 17标准(这里的草案)时,教派.4.7.1(4),即"所有的修改以使特定原子对象中号发生在一些特定的总次序,被称为修饰顺序的中号 " -和当标准反复采用类似的语言来分隔以往更精确逻辑并发-I我想确保我不会无意中误解.

我是否正确地假设短语"原子对象"的意思

• 对象的原子类型？

我能想象的唯一合理的选择是这个短语的意思

• 正确对齐的对象足够小,硬件可以原子地处理它.

请问是哪一个？

(注意:我在C和C++上都标记了这个问题,因为当涉及原子时,这两个标准使用几乎相同的语言.因此,就我所知,任何一种语言的专家都可以回答.如果由于某种原因,我是错了,那么请删除C标签并保留C++.)

参考:另见这个问题,我的问题是初步的.