在大多数Unix和Posix符合操作系统下,使用O_APPEND执行open()操作系统调用向操作系统指示写入是原子追加和写入操作.出现这种情况,对于本地文件系统,当您执行写操作时,您知道它会附加到文件的末尾.
Windows操作系统通过将FILE_APPEND_DATA适当的参数传递给Win32 CreateFile()系统调用来支持相同的功能.
引用:
http://www.google.com/search?q=msdn+createfile
or: http://msdn.microsoft.com/en-us/library/aa363858(VS.85).aspx
http://www.google.com/search?q=msdn+IoCreateFileSpecifyDeviceObjectHint
or: http://www.google.com/search?q=msdn+IoCreateFileSpecifyDeviceObjectHint
我的问题是,我无法确定如何使用Net Framework库在C#下获得此行为,有没有办法使用Net Framework获取此类行为？我不相信使用FileMode.Append会提供这样的行为.
我有一个类似下面的课程.
#include <atomic>
static const long myValue = 0;
class Sequence
{
public:
Sequence(long initial_value = myValue) : value_(initial_value) {}
private:
std::atomic<long> value_;
};
int main()
{
Sequence firstSequence;
Sequence secondSequence = firstSequence;
return 0;
}
我收到这样的编译错误,
test.cpp:21:36: error: use of deleted function ‘Sequence::Sequence(const Sequence&)’
test.cpp:5:7: error: ‘Sequence::Sequence(const Sequence&)’ is implicitly deleted because the default definition would be ill-formed:
test.cpp:5:7: error: use of deleted function ‘std::atomic<long int>::atomic(const std::atomic<long int>&)’
这是默认的复制构造函数,赋值opertaor在这种情况下不起作用吗？
PS:我使用的是gcc 4.6.3版
file_put_contents ( "file", "data", LOCK_EX )
写作(意思是 - 获取锁定和写入)
file_get_contents ( "file", LOCK_EX )
用于阅读(这意味着 - 获取锁定然后阅读)
它会抛出异常吗？提出错误？阻止直到获得锁定？或者至少 - 应该吗？有一天php会有这样的表现吗？
编辑:我知道可以使用重命名 - 我想知道答案...
我正在编写一些无锁代码,我想出了一个有趣的模式,但我不确定它是否会在轻松的内存排序下表现得如预期.
解释它的最简单方法是使用一个例子:
std::atomic<int> a, b, c;
auto a_local = a.load(std::memory_order_relaxed);
auto b_local = b.load(std::memory_order_relaxed);
if (a_local < b_local) {
auto c_local = c.fetch_add(1, std::memory_order_relaxed);
}
请注意,所有操作都使用std::memory_order_relaxed.
显然,在这上,负载为执行的线程a,并b在之前必须完成if情况进行评估.
类似地,读取 - 修改 - 写入(RMW)操作c必须在评估条件之后完成(因为它以条件为条件).
我想知道的是,这段代码保证的价值c_local至少高达最新的值a_local和b_local？如果是这样,如果放宽内存排序,这怎么可能？控制依赖是否与RWM操作一起充当某种获取范围？(请注意,在任何地方都没有相应的版本.)
如果上述情况属实,我相信这个例子也应该有效(假设没有溢出) - 我是对的吗？
std::atomic<int> a(0), b(0);
// Thread 1
while (true) {
auto a_local = a.fetch_add(1, std::memory_order_relaxed);
if (a_local >= 0) { // Always true at runtime
b.fetch_add(1, std::memory_order_relaxed);
}
} …我在一个交叉点,我试图在基于互斥锁的数据结构和无锁(可能无等待)的数据结构之间选择一个.
虽然挖掘得更深,但我没有发现C++ 11标准支持原子类型的原子操作这一事实,甚至对于基于宽度的积分也没有atomic_uint32_t.换句话说,它不仅仅是未被授予真正原子的std::atomic<>接口,唯一看起来它被赋予整个标准库中的原子的东西是.std::atomic_flag
这是真的还是我遗失了什么？这是什么原因？我的意思是标准称为"原子"的东西显然根本不是原子的,甚至允许使用互斥锁或阻止呼叫.
我阅读以下通过文章安东尼威廉姆斯和我除了理解为原子共享计数std::shared_ptr在std::experimental::atomic_shared_ptr实际指针到共享对象也是原子？
但是,当我读到的引用计数的版本lock_free_stack在安东尼的书中描述了关于C++并发似乎对我来说,同样aplies也是std::shared_ptr,因为功能,如std::atomic_load,std::atomic_compare_exchnage_weak被应用到的实例std::shared_ptr.
template <class T>
class lock_free_stack
{
public:
void push(const T& data)
{
const std::shared_ptr<node> new_node = std::make_shared<node>(data);
new_node->next = std::atomic_load(&head_);
while (!std::atomic_compare_exchange_weak(&head_, &new_node->next, new_node));
}
std::shared_ptr<T> pop()
{
std::shared_ptr<node> old_head = std::atomic_load(&head_);
while(old_head &&
!std::atomic_compare_exchange_weak(&head_, &old_head, old_head->next));
return old_head ? old_head->data : std::shared_ptr<T>();
}
private:
struct node
{
std::shared_ptr<T> data;
std::shared_ptr<node> next;
node(const T& data_) : data(std::make_shared<T>(data_)) {} …我正在学习不同的记忆顺序。
\n我有这段代码，它可以工作并通过 GCC 和 Clang 的线程清理程序：
\n#include <atomic>\n#include <iostream>\n#include <future>\n \nint state = 0;\nstd::atomic_int a = 0;\n\nvoid foo(int from, int to) \n{\n for (int i = 0; i < 10; i++)\n {\n while (a.load(std::memory_order_acquire) != from) {}\n state++;\n a.store(to, std::memory_order_release);\n }\n}\n\nint main()\n{ \n auto x = std::async(std::launch::async, foo, 0, 1);\n auto y = std::async(std::launch::async, foo, 1, 0);\n}\n我认为如果它最终没有返回，则“获取”加载是不必要的from，那么“获取”负载是不必要的，因此我决定使用“宽松”负载，然后使用“获取”栅栏。
我期望它能工作，但它被线程清理程序拒绝了，线程清理程序声称并发state++是数据竞争。
#include <atomic>\n#include <iostream>\n#include <future>\n \nint state = 0;\nstd::atomic_int …我完全理解Threading.Interlocked类提供的原子性; 但是,我不明白为什么Add函数只提供两个重载:一个用于Integers,另一个用于Longs.为什么不双打,或任何其他数字类型？
显然,更改Double的预期方法是CompareExchange; 我认为这是因为修改Double比修改Integer更复杂.我还不清楚为什么,如果CompareExchange和Add都能接受整数,他们也不能同时接受双打.
我想知道Linq扩展方法是否是原子的？或者,在进行任何迭代之前,我是否需要跨线程使用的lock任何IEnumerable对象？
声明变量volatile对此有何影响？
总结一下,以下哪项是最好的,线程安全,操作？
1-没有任何锁:
IEnumerable<T> _objs = //...
var foo = _objs.FirstOrDefault(t => // some condition
2-包括锁定语句:
IEnumerable<T> _objs = //...
lock(_objs)
{
var foo = _objs.FirstOrDefault(t => // some condition
}
3-将变量声明为volatile:
volatile IEnumerable<T> _objs = //...
var foo = _objs.FirstOrDefault(t => // some condition