1.线程：独立调度的基本单位。进程： 资源分配的基本单位。

2.C++11新标准多线程支持库
< thread > : 提供线程创建及管理的函数或类接口；
< mutex > : 为线程提供获得独占式资源访问能力的互斥算法，保证多个线程对共享资源的同步访问；
< condition_variable > : 允许一定量的线程等待（可以定时）被另一线程唤醒，然后再继续执行；
< future > : 提供了一些工具来获取异步任务（即在单独的线程中启动的函数）的返回值，并捕捉其所抛出的异常；
< atomic > : 为细粒度的原子操作（不能被处理器拆分处理的操作）提供组件，允许无锁并发编程。

3.多线程间通信方式

（1）互斥锁
mutex;
lock_guard (在构造函数里加锁，在析构函数里解锁）
unique_lock 自动加锁、解锁
atomic 基本类型的原子操作
（2）条件变量condition_variable
关于互斥锁和条件变量：
互斥量可以保护共享数据的修改，如果线程正在等待共享数据的某个条件出现，仅用互斥量的话就需要反复对互斥对象锁定解锁，以检查值的变化，这样将频繁查询的效率非常低。
条件变量可以让等待共享数据条件的线程进入休眠，并在条件达成时唤醒等待线程，提供一种更高效的线程同步方式。条件变量一般和互斥锁同时使用，提供一种更高效的线程同步方式。
（3）信号量
（4）读写锁shared_lock

4.进程间的通信方式

（1）. 管道pipe：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
（2）. 命名管道FIFO：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
（3） 消息队列MessageQueue：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
（4）. 共享存储SharedMemory：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。
（5）. 信号量Semaphore：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
（6）套接字Socket：套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。
（7） 信号 ( sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。

普通函数多线程调用

//C++11中std命名空间将Boost库中的Thread加入
//Boost的多线程从准标准变为标准，在深度学习以及应用程序开发中经常用到多线程
#include<thread>
#include<iostream>
#include<mutex>
using namespace std;
void helloThread()
{cout<<"hello Thread"<<endl;
} 
int sum(int a,int b){int c=a+b;cout<<a<<'+'<<b<<'='<<c<<endl;return c;
} 
int main(){//thread t1(helloThread);thread t1(sum,1,2);//子线程运行结束后可执行下一步 t1.join();//主线程代码 cout<<"main here"<<endl;getchar();return 0;
}

在类内部创建线程

#include<thread>
#include<iostream>
#include<mutex>
using namespace std;
//start()和hellothread()方法都必须是static方法
class helloThread{public:static void hellothread(){cout<<"hello I am a thread"<<endl;}static void start(){thread t1(hellothread);t1.join();}
};
int main(){helloThread::start();getchar();return 0;
}

在Singleton模式内部创建线程.

#include<thread>
#include<iostream>
#include<mutex>
using namespace std;
//在Singleton模式内部创建线程.
class helloWorld{public:void hello(){cout<<"hello I am a thread"<<endl;}static void start(){thread t1(bind(&helloWorld::hello,&helloWorld::getInstance()));t1.join();}static helloWorld& getInstance(){if(!instance) instance=new helloWorld;return *instance; }private:helloWorld(){	};static helloWorld *instance;	
};
helloWorld* helloWorld::instance=0;
int main(int argc,char *argv[]){helloWorld::start();getchar();return 0;
}

用类内部函数在类外部创建线程

#include<thread>
#include<iostream>
#include<mutex>
using namespace std;
//用多线程调用其内部的函数
class helloWorld{public:void hello(int year){cout<<"I am "<<year<<" years old"<<endl;}}; 
int main(int argc,char *argv[]){helloWorld obj;thread t1(bind(&helloWorld::hello,&obj,23));t1.join();//join()的作用,主线程等待子线程结束方可执行下一步（串行）//join()函数是一个等待线程完成函数,主线程需要等待子线程运行结束了才可以结束//注意不是才可以运行，运行是并行的getchar();return 0;
}

detach()

#include<thread>
#include<iostream>
#include<mutex>
using namespace std;
//detach()子线程独立于主线程并发执行,主线程后续代码段无需等待
//detach()函数是子线程的分离函数,当调用该函数后,线程就被分离到后台运行，
主线程不需要等待该线程结束才结束
void helloThread(){	cout<<"hello thread"<<endl;	 cout<<endl;
}
int g_sum(int a,int b){int c=a+b;cout<<a<<'+'<<b<<'='<<c<<endl;return c;
}
int main(int argc,char *argv[]){thread t1(helloThread);thread t2(g_sum,2,3);t1.detach();t2.detach();cout<<"main here"<<endl;getchar();return 0;
}

数据同步（线程同时操作一个数据的安全性）

#include<thread>
#include<iostream>
#include<mutex>
using namespace std;
mutex mt;
int data=1;
void addMethod(int a){mt.lock();data+=a;cout<<"add data= "<<data<<endl;mt.unlock();
}
void multi(int a){mt.lock();data *=a;cout<<"multi data= "<<data<<endl;mt.unlock();
}
int main(int argc,char *argv[]){thread t1(addMethod,2);//3thread t2(multi,10);//30t1.detach();t2.detach();getchar();return 0;
}