用C++11学习多线程

有了线程，多核才有了真正意义上的并发。在单核时代，所谓的并发只是伪并发，类似于事件轮询的方式。只是轮询的周期比较快，所以对于我们人类来说看上去和真的并发没什么区别。如果把主人公换成复仇者联盟2上的快银，在他的世界观里。。。呵呵

并发毫无疑问能提高工作效率，但也肯定会有一些问题需要注意。很明显的一个问题就是，对于共享资源的访问。因为线程之间是栈私有，堆共有的。对于局部变量不会有什么问题，但如果两个线程同时访问一个共享变量，这个时候就需要注意了。为了处理并发带来的隐患，我们发明了互斥量，信号量，条件变量，屏障等概念来处理线程对共享资源的访问。

在只有进程的年代，我们貌似只能通过fork之类的方式来复制一个进程，进程之间貌似没有同步的概念。进程之间只有通信。对于Unix IPC和网络编程，我肯定推荐Richard的著作，APUE和Unix网络编程。他老人家已经于1999年去世了，希望在天堂一切都好吧。

对于并发，不同平台有不同的实现。Windows上有Win32的API供你调用，Linux上也有一套自己的接口。好在POSIX的出现为我们编写可移植的程序提供了方便。同时C++11中以提供了一套跨平台的线程库。具体看见：传送门

用C++11写一个多线程的小程序：

#include <iostream>
#include <thread>
#include <cassert>
using namespace std;
//calc the Nth items of Fib series
void f1(int n){
assert(n>0);
for(int i=0;i<5;i++){
cout<<"thread f1 is running."<<endl;
++n;
}
}
void f2(int &n){
assert(n>=0);
for(int i=0;i<5;i++){
cout<<"thread f2 is running."<<endl;
++n;
}
}
int main(void){
int n=0;
std::thread t1(f1,n+1);
std::thread t2(f2,std::ref(n));
t1.join();
t2.join();
cout<<"At the last the n's value is: "<<n<<endl;
return 0;
}

程序就是上面这样，很简单。创建两个线程，每个线程各有一条打印语句。其中第二个线程是传引用。多运行几次程序，你就会发现两个线程的打印语句的执行顺序是不确定的，原因完全是因为处理器的调度。

代码也没什么好说的，只是要注意

thread(const thread&) = delete;

这是一个被删除的函数，也就是说不支持拷贝赋值。

例子2 线程报数

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <atomic>
using namespace std;
atomic<int> login_count;
int thread_num=50;   //创建线程数
int TIMES=20;        //查看次数
void f(void){
login_count.fetch_add(1,std::memory_order_relaxed);
Sleep(50);
}
int main(int argc,char **argv){
thread pool[thread_num];
while(TIMES-->0){
login_count=0;
for(int i=0;i<thread_num;i++){
thread t(f);
pool[i]=std::move(t);
}
//wait every thread finish his task
for(int i=0;i<thread_num;i++)
pool[i].join();

cout<<"50 users login.The output is: "<<login_count<<endl;
}
return 0;
}

程序的功能如下：启动一个线程，就报一个数。可见于某网站统计用多少人登录吧。这里主要用到了原子操作。

login_count.fetch_add(1,std::memory_order_relaxed);

打印结果见下图。是没有错误的，不过看官可以试一下不用原子操作。也就是最野性的

longin_count++:

结果肯定不正确。理由也很简单：自加操作的汇编代码有三步：

1：move data from memory to register

2：add the data in register

3：move data back to memory

所以如果第一个线程执行到在寄存器中加1时被CPU挂起，此时运行第二个线程。。。。。



除了原子操作，互斥量和信号量都能用来应对这种情况。所谓至于为什么叫原子操作，类比我们物理中的原子啦。是不可分割的最小单位，编程中的原子性是指。一个操作要么做完，要么不做。比如你像朋友打钱，打到一半断电了。。。这时候怎么办？

数据库中也有类似的概念，貌似叫做事务性。

java version

import java.util.concurrent.*;

public class my_runnable implements Runnable{
int count=1,number;
//constructor
public my_runnable(int number){
this.number=number;
}
public void run(){
while(true){
System.out.println("thread ID is: " + number+"  current number is: " + count);
if(++count==6)
return ;
}
}
public static void main(String[] args){
for(int i=0;i<2;i++)
new Thread(new my_runnable(i+1)).start();
}
}

运行一下很明显就能看到多线程的效果。