原文：https://learn.microsoft.com/en-us/archive/msdn-magazine/2012/december/csharp-the-csharp-memory-model-in-theory-and-practice

半内存屏障

例如有这样的程序，Init()和Print()在不同的线程上执行。

int data = 0;
bool inited = false; // 指示data字段是否已经设置的标志

void Init(){
    data = 42;
    inited = true; // 设置标志，指示data字段已经设置好了
}
void Print(){
    // 如果有inited的标志，打印data字段的值
    // 否则打印 Not initialized!
    if(inited){
        Console.WriteLine(data);
    }else{
        Console.WriteLine("Not initialized!");
    }
}

今天在写一个显示当前时间的网页，用了一个回调，来每秒更新时间。
但是实际运行时，时间并没有动态更新。

原因

仔细查了一下，原来是 Javascript 函数的 this 是在调用函数时确定的。

foo.call(this,args...);

观察一下函数的call函数的签名，可以发现第一个参数传入了 this 的值，函数运行时的 this 就是调用时传入的 this。
而回调函数被执行时，this已经不是我们原来预想的this了，所以变量没有被更改。

解决

那么如果要用回调函数，使用原来的this，该怎么办呢？
函数里提供了bind函数，可以用来内定函数调用时this的值和参数。

foo.bind(this,args...);

而在bind时写的参数，在执行时就会被插入到参数列表的最前面，可以用来内定前几个参数的值。
调用了bind之后，返回的是一个新的函数，它的this和前几个参数已经被内定死了。
之后函数被调用时无论传入的this是什么，实际执行时的this始终都是bind时内定好的this。

Intent 可以用于启动 Activity 或者在 Activity 间传递数据。

显式启动 Activity

// new Intent(Context context, Class class)
Intent intent = new Intent(this, TargetActivity.class);
startActivity(intent);

意图明确的 Intent，明确指出在 this 的 context 上启动 TargetActivity。

隐式启动 Activity

首先在 AndroidManifest.xml 中 Activity 的 <intent-filter> 中定义 <action> 和 <category>。

<activity android:name=".TargetActivity">
    <intent-filter>
        <!-- 可以有多个action和category -->
        <action android:name="com.example.test.ACTION_START"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <category android:name="com.example.test.MY_CATEGORY"/>
    </intent-filter>
</activity>

最近好好研究了一下 C++ 中的移动语义。

左值 & 右值

已经在内存中分配了地址的、可以取到地址的，是左值。
在内存中未分配地址的、仅存在于寄存器中、无法取到地址的，是右值。

int a = 8; // a 已分配内存，是左值。
a + 1; // a + 1 仅存在于寄存器中，是右值。

右值引用

T&& 是右值引用，只接受右值：

int&& a = 8; // 正确，8 仅存在于寄存器中。

int v = 9;
int&& b = v; // 错误，v 是左值，无法存入右值引用。
int&& c = v + 3; // 正确，v + 3 的结果仅存在于寄存器中，是右值，可以存入右值引用。

原文链接
原作者：Valentina Di Vincenzo
仅供个人学习、研究和欣赏

当我刚开始学 C++ 多线程的时候，我凌乱了。程序的复杂度如同一朵美丽的鲜花一样炸开了，并发的不确定行为要把我骨灰都给扬咯，当时我直接蒙了。如今你被我逮到了，我给你整个好活儿：这里是一份关于 C++ 并发和多线程的简易教程，放心，这个不会三天之内sa了你。

现在，来快速复习一些基本概念，然后来雅间尝点并发代码。

概念

什么是线程？

在进程被创建时，每个进程都有一个单独用来执行代码的线程，叫主线程。你可以向操作系统请求创建其他的线程，这些线程共享父进程的内存空间（代码区，数据区，其他操作系统资源，比如说打开的文件和信号）。另一方面，每个线程有各自的线程ID，栈，寄存器组和程序计数器。基本上来说，线程就是轻量的进程。在线程之间切换比进程快，线程间通信也比进程间通信更容易。

什么是并发？

随着时间，操作系统的任务调度器会给可用的 CPU 核心分配线程来运行，而且具有不确定性。这叫做硬件并发：多个线程并行运行在不同核心上，每个线程运行着程序的特定任务。

任务切换

用 std::thread 实现基本线程操作

头文件：#include <thread>

创建线程

std::thread t(callable_object, arg1, arg2, ..)

创建了一个线程 t，线程会立刻调用 callable_object(arg1, arg2, ..)。
callable_object 可以是函数指针、匿名函数、具有函数调用操作符重载的对象。
默认情况下 callable_object 是值传递，如果你想引用传递的话，就用 std::ref(arg) 包一下。
另外如果你想传递 unique_ptr 的话，你得用 std::move(arg) 移动给参数，毕竟 unique_ptr 没法复制。

线程生命周期

t.join() 以及 t.detach()。
如果主线程退出了，其他所有仍在运行的副线程也会立马终止，没有任何办法恢复。为了避免这种情况发生，父线程对于子线程有两个选项：

• 调用子线程的 join() 方法，阻塞当前线程并等待子线程结束。
• 调用子线程的 detach() 方法，显式声明子线程可以在父线程退出后继续运行。

你能在这里找到示例代码。

4. 为什么需要同步？

因为线程都共享相同的内存空间和资源，很多操作都变得很苛刻：多线程操作需要同步原语。来讲讲为什么。

• 内存是鬼屋
  有了多线程之后，内存没法再被当作是个“静态的仓库”了。想象一下：一个线程正在看摇摆阳跳舞，突然电视没了！他慌啊，打了 110…… 结果电话那头是“老八秘制小汉堡，即实惠又管饱”。咋回事？很简单，房子里百鬼夜行（鬼是其他线程）：它们都在同一个房间，和同样的物体交互（这叫做 data race，数据争用），但是每个鬼看不见其他鬼。

数据争用

为了整安全点儿，线程应该得声明它正在使用哪个东西，并且在使用东西之前先检查东西是否正在被使用。绿色线程有没有在看电视？有的话，那就不应该有其他人来碰电视（就算有的话，其他人也只应该来一起坐着看电视）。这可以通过互斥体来做到。

int tmp = a;
a = tmp + 1;

解决这个问题最简单的方法是使用 std::atomic，这个模板类可以给很多类型做成原子操作。

• 缓存一致性、乱序执行

代码范例

来看一些代码，自己也来测试一下多线程的不确定行为。

#include <thread>
#include <iostream>
#include <string>

void run(std::string threadName) {
  for (int i = 0; i < 10; i++) {
    std::string out = threadName + std::to_string(i) + "\n";
    std::cout << out;
  }
}

int main() {
  std::thread tA(run, "A");
  std::thread tB(run, "\tB");
  tA.join();
  tB.join();
}

可能的输出：

   B0
A0
A1
A2
   B1
A3
   B2
   B3
...

与单线程不同，每次执行都会产生不同且不可预测的输出（唯一能确定的就是数字在自增）。当指令执行顺序很重要的时候，会发生问题。

#include <thread>
#include <iostream>
#include <string>

void runA(bool& value, int i) {
  if(value) {
      //进入了if，value应该总是1
      std::string out = "[ " + std::to_string(i) + " ] value " + std::to_string(value)  + "\n";
      std::cout << out;
  }
}

void runB(bool& value) {
    value = false;
}
int main() {
    for(int i = 0; i < 20; i++) {
        bool value = true; //true == 1
        std::thread tA(runA, std::ref(value), i);
        std::thread tB(runB, std::ref(value));
        tA.join();
        tB.join();
    }
}

可能的输出：

...
[ 12 ] value 0
[ 13 ] value 1
[ 14 ] value 0
[ 15 ] value 0
[ 16 ] value 0
[ 17 ] value 0
[ 18 ] value 1
[ 19 ] value 0
...

（runA() 中打印输出的部分被套在了if中，只有 value 为 true 的时候才能打印，那么打印出来的 value 应该始终为 1，但是输出中却有时打印了 0）

这里发生了什么？——在线程 A 确定 value 是 true 之后，线程 B 修改了 value 的值。尽管 if 约束已经被打破，但是代码已经执行到了 if 代码块的内部。

如果两个线程访问相同数据，一个读、一个写，则无法保证哪个操作先执行。

对数据的访问必须进行同步

结论

概念信息量很大，但是你不需要现在立马就理解一切，重要的是抓住核心概念。

建议去把玩一下示例代码，看一看并发是怎样执行的。然后也去试着思考一下其他需要同步的地方，测试一下（比如说：如果有多个线程同时对一个队列进行出队操作呢？别忘了出队前先得检查一下队列是不是空的）。

（C++11 标准库引入了进行同步的机制，不依赖底层平台，所以这个系列将不会讨论 Linux 和 Windows 平台上特定的线程库。总之，核心概念都差不多。）

在下一篇文章，我们会看看互斥器同步原语，看看怎样最好地使用它。