多线程的些许理解
一.体系架构
1.原子操作
1） 定义
不可中断的一个或者一系列操作，也就是不会被线程调度机制打断的操作，在运行期间不会有任何的上下文切换(context switch).
2) 我们为什么关注原子操作（what）
在多线程操作的时候，确定某个操作非原子操作，要用消耗性能的昂贵的锁去保护。
3）单核CPU、多核CPU
在单核CPU中，能够在一个指令中完成的操作都可以看作为原子操作，因为中断只发生在指令间。
在多核CPU中，软件级别的原子操作依赖于硬件支持的，在X86体系中，CPU提供了HLOCK pin引 线，允许CPU在执行某个指令（仅仅是一个指令）时拉低HLOCK pin引线的电平，直到这个这个指令执行完毕才放开。拉低电平导致锁住总线，如此在同一总线的CPU就暂时无法通过总线访问内存了，这样就保证了多核处理器的原子操作。（在那段时间，我猜测，处理器，在想为啥内存访问被禁止，什么鬼，交 通管制，又是哪个大领导来视察）
4）如何定义操作原子操作
对于非long和double基本数据类型的“简单操作”都可以看作原子操作。for example：赋值和返回。在大多数系统中long和double都占据8个字节，操作系统或者JVM（java虚拟机）很可能会将写入和读取操作分离成两个独立的操作来执行，这就产生一个读取和写入过程中的上下文切换，从而导致多线程看到不正确的情况。
自增，自减非原子操作，一共三步（两次内存访问，一次寄存器修改）
比如：x++;(没有招，兄弟牺牲点性能吧）
mov eax,dword ptr [x]
add eax,1
mov dword ptr [x],eax
二、操作系统之上的实现
讲点没有用，有大咖测试发现，在linux上进程和线程的效率差不多，window上进程和线程效率差距很大。
1.window上多线程同步和互斥操作
分别有四种方式：临界区（CriticalSection)、互斥对象（Mutex）、信号量（Semaphore）、事件对象（Event）。
1）临界区：
使用函数：
CRITICAL_SECTION CriticalSection;
InitializeCriticalSection(&CriticalSection);
EnterCriticalSection(&CriticalSection);
LeaveCriticalSection(&CriticalSection);
DeleteCriticalSection(&CriticalSection);
write an example:
#include <string>
#include <iostream>
#include < process.h>
#include <windows.h>
using namespace std; CRITICAL_SECTION g_cs; unsigned __stdcall threadFun(void *param)
{
EnterCriticalSection(&g_cs);
cout<<*(string*)(param)<<endl;
LeaveCriticalSection(&g_cs);
return 1;
} int main()
{
InitializeCriticalSection(&g_cs); HANDLE hth1, hth2, hth3;
string s1 = "first", s2 = "second", s3= "third"; hth1 = (HANDLE)_beginthreadex(NULL, 0, threadFun, &s1, 0, NULL);
hth2 = (HNADLE)_beginthreadex(NULL, 0, threadFun, &s2, 0, NULL);
hth3 = (HNADLE)_beginthreadex(NULL, 0, threadFun, &s3, 0, NULL); WaitForSingleObject(hth1, INFINITE);
WaitForSingleObject(hth2, INFINITE);
WaitForSingleObject(hth3, INFINITE); CloseHandle(hth1);
CloseHandle(hth2);
CloseHandle(hth3); DeleteCriticalSection(&g_cs);
return 0;
}
2) 互斥对象(Mutex）
引入了对象互斥对象的概念，来保证共享数据操作的完整性，每个对象对应于一个可称为互斥锁的标记，用这个标记用来保证在任一时刻，只要有一个线程访问该对象，操作接口：
CreateMutex
OpenMutex
ReleaseMutex
write an example:
#include<string>
#include<iostream>
#include<process.h>
#include<windows.h>
using namespace std； HANDLE hmu; unsined __stdcall threadFun(void *param)
{
WaitForSingleObject(hmu, INFINITE);
cout<<*(string*)(param)<<endl;
ReleaseMutex(hmu);
return 1;
} int main()
{
hmu = CreateMutex(NULL, FALSE, NULL);
HANDLE hth1, hth2, hth3;
string s1 = "first", s2 = "second", s3 = "third"; hth1 = (HANDLE)_beginthreadex(NULL, 0, threadFun, &s1, 0, NULL);
hth2 = (HANDLE)_beginthreadex(NULL, 0, threadFun, &s2, 0, NULL);
hth3 = (HANDLE)_beginthreadex(NULL, 0, threadFun, &s3, 0, NULL); WaitForSingleObjec(hth1, INFINITE);
WaitForSingleObjec(hth2, INFINITE);
WaitForSingleObject(hth3, INFINITE); CloseHandle(hth1);
CloseHandle(hth2);
CloseHandle(hth3); CloseHandle(hmu);
return 0; }
3）信号量（Semaphore）
信号量，别称信号灯。负责协调各个线程，保证正确合理的使用公共资源。
window环境接口：
CreateSemaphore
OpenSemaphore
ReleaseSemaphore
write an example:
#include <string>
#include <iostream>
#include <process.h>
#include <windows.h> using namespace std; HANDLE hsem1, hsem2, hsem3; usigned __stdcall threadFunA(void *)
{
for(int i = 0; i < 10; i++)
{
WaitForSingleObject(hsem1, INFINITE);
cout<<"A";
ReleaseSemaphore(hsem2, 1, NULL);
}
return 1;
} unsigned __stdcall threadFunB(void*)
{
for(int i = 0; i < 10; i++)
{
WaitForSingleObject(hsem2, INFINITE);
cout<<"B";
ReleaseSemaphore(hsem2, 1, NULL);
}
return 1;
} unsigned __stdcall threadFunC(void*)
{
for(inti =0; i < 10; i++)
{
WaitForSingleObject(hsem3, INFINITE);
cout<<"C";
ReleaseSemphore(hsem1, 1, NULL);
}
return 1;
} int main()
{
hsem1 = CreateSemaphore(NULL, 1, 1, NULL);
hsem2 = CreateSemaphore(NULL, 0, 1, NULL);
hsem3 = CreateSemaphore(NULL, 0, 1, NULL); HANDLE hth1, hth2, hth3; hth1 = (HANDLE)_beginthreadex(NULL, 0, threadFunA, NULL, 0, NULL);
hth2 = (HANDLE)_beginthreadex(NULL, 0, threadFunB, NULL, 0, NULL);
hth3 = (HANDLE)_beginthreadex(NULL, o, threadFunC, NULL, 0, NULl); WaitForSingleObject(hth1, INFINITE);
WaitForSingleObject(hth2, INFINITE);
WaitForSingleObject(hth3, INFINITE); CloseHandle(hth1);
CloseHandle(hth2);
CloseHandle(hth3);
CloseHandle(hsem1);
CloseHandle(hsem2);
CloseHandle(hsem3);
return 0;
}
4) 事件对象（Event）
windows事件操作
CreateEvent
OpenEvent
PulseEvent
ResetEvent
SetEvent
主线程一般可以这样写：
CreateEvent(/*...*/); // 创建事件对象
SetEvent(/*...*/); // 设置信号
WaitForMultiObjects(hThread, /*...*/); // 等待线程结束
CloseHandle(/*...*/); // 关闭线程句柄
而被启动的线程一般要等待某个事件再进行操作：
while(1){
WaitForSingleObject(/*...*/); // 等待事件
/*...*/
}
总结：
1. 使用频率，信号量 > 互斥对象 > 临界区 > 事件对象
2. windows编程中有两种创建线程的方法，一种为CreateThread(），另一种为_beginthreadex()，当如果代码使用标准C运行库，建议使用后者。 （window API的好）
2.linux c 多线程编程
无非也是锁机制，条件变量，读写锁，在linux编程中多线程和多进程差不多，无非API改改名，不做太多探讨。
write simple an example:
#include"../apue.h"
int pos=0;
char *list[10]={"person1","person2","person3","person4","person5",
"person6","person7","person8","person9","person10"}; pthread_mutex_t mutex;
void *func(void *p)
{
int a = *(int*)p;
for(;;)
{
pthread_mutex_lock(&mutex);
if(pos>=10)
{
break;
}
printf("%d号咨询美女为%s服务\n",a,list[pos]);
pos++;
pthread_mutex_unlock(&mutex);
sleep(8);//模拟服务时间
}
pthread_mutex_unlock(&mutex);
}
int main()
{
int i;
int a=1,b=2,c=3;
pthread_t id1,id2,id3;
pthread_mutex_init(&mutex,NULL);
pthread_create(&id1,NULL,func,&a);
pthread_create(&id2,NULL,func,&b);
pthread_create(&id3,NULL,func,&c); pthread_join(id1,NULL);
pthread_join(id2,NULL);
pthread_join(id3,NULL);
while(1);
}
参考：网上的博客 （集百家之所长，补自己之所短）
《UNIX环境高级编程》这本书看完了，验证一遍，linux基本操作都应该没啥问题。