线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。
1）互斥锁（mutex）
通过锁机制实现线程间的同步。同一时刻只允许一个线程执行一个关键部分的代码。
int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutex_attr_t *mutexattr)
int pthread_mutex_lock(pthread_mutex *mutex)
int pthread_mutex_destroy(pthread_mutex *mutex)
int pthread_mutex_unlock(pthread_mutex *
(1)先初始化锁init()或静态赋值pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIER
attr_t有:
PTHREAD_MUTEX_TIMED_NP:其余线程等待队列
PTHREAD_MUTEX_RECURSIVE_NP:嵌套锁,允许线程多次加锁,不同线程,解锁后重新竞争
PTHREAD_MUTEX_ERRORCHECK_NP:检错,与一同,线程请求已用锁,返回EDEADLK
PTHREAD_MUTEX_ADAPTIVE_NP:适应锁,解锁后重新竞争
(2)加锁,lock,trylock,lock阻塞等待锁,trylock立即返回EBUSY
(3)解锁,unlock需满足是加锁状态,且由加锁线程解锁
(4)清除锁,destroy(此时锁必需unlock,否则返回EBUSY,//Linux下互斥锁不占用内存资源
示例代码
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <pthread.h>
#include "iostream"
using namespace std
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
int tmp
void* thread(void *arg)
{
cout <<"thread id is " <<pthread_self() <<endl
pthread_mutex_lock(&mutex)
tmp = 12
cout <<"Now a is " <<tmp <<endl
pthread_mutex_unlock(&mutex)
return NULL
}
int main()
{
pthread_t id
cout <<"main thread id is " <<pthread_self() <<endl
tmp = 3
cout <<"In main func tmp = " <<tmp <<endl
if (!pthread_create(&id, NULL, thread, NULL))
{
cout <<"Create thread success!" <<endl
}
else
{
cout <<"Create thread failed!" <<endl
}
pthread_join(id, NULL)
pthread_mutex_destroy(&mutex)
return 0
}
编译： g++ -o thread testthread.cpp -lpthread
说明：pthread库不是Linux系统默认的库，连接时需要使用静态库libpthread.a，所以在使用pthread_create()创建线程，以及调用pthread_atfork()函数建立fork处理程序时，需要链接该库。在编译中要加 -lpthread参数。
2）条件变量（cond）
利用线程间共享的全局变量进行同步的一种机制。条件变量上的基本 *** 作有：触发条件(当条件变为 true 时)；等待条件，挂起线程直到其他线程触发条件。
int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr)
int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex)
int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime)
int pthread_cond_destroy(pthread_cond_t *cond)
int pthread_cond_signal(pthread_cond_t *cond)
int pthread_cond_broadcast(pthread_cond_t *cond) //解除所有线程的阻塞
(1)初始化.init()或者pthread_cond_t cond=PTHREAD_COND_INITIALIER（前者为动态初始化，后者为静态初始化）属性置为NULL
(2)等待条件成立.pthread_wait,pthread_timewait.wait()释放锁,并阻塞等待条件变量为真，timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)
(3)激活条件变量:pthread_cond_signal,pthread_cond_broadcast(激活所有等待线程)
(4)清除条件变量:destroy无线程等待,否则返回EBUSY
对于
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
一定要在mutex的锁定区域内使用。
如果要正确的使用pthread_mutex_lock与pthread_mutex_unlock，请参考
pthread_cleanup_push和pthread_cleanup_pop宏，它能够在线程被cancel的时候正确的释放mutex！
另外，posix1标准说，pthread_cond_signal与pthread_cond_broadcast无需考虑调用线程是否是mutex的拥有者，也就是说，可以在lock与unlock以外的区域调用。如果我们对调用行为不关心，那么请在lock区域之外调用吧。
说明：
(1)pthread_cond_wait 自动解锁互斥量(如同执行了pthread_unlock_mutex)，并等待条件变量触发。这时线程挂起，不占用CPU时间，直到条件变量被触发（变量为ture）。在调用 pthread_cond_wait之前，应用程序必须加锁互斥量。pthread_cond_wait函数返回前，自动重新对互斥量加锁(如同执行了pthread_lock_mutex)。
(2)互斥量的解锁和在条件变量上挂起都是自动进行的。因此，在条件变量被触发前，如果所有的线程都要对互斥量加锁，这种机制可保证在线程加锁互斥量和进入等待条件变量期间，条件变量不被触发。条件变量要和互斥量相联结，以避免出现条件竞争——个线程预备等待一个条件变量，当它在真正进入等待之前，另一个线程恰好触发了该条件（条件满足信号有可能在测试条件和调用pthread_cond_wait函数（block）之间被发出，从而造成无限制的等待）。
(3)pthread_cond_timedwait 和 pthread_cond_wait 一样，自动解锁互斥量及等待条件变量，但它还限定了等待时间。如果在abstime指定的时间内cond未触发，互斥量mutex被重新加锁，且pthread_cond_timedwait返回错误 ETIMEDOUT。abstime 参数指定一个绝对时间，时间原点与 time 和 gettimeofday 相同：abstime = 0 表示 1970年1月1日00:00:00 GMT。
(4)pthread_cond_destroy 销毁一个条件变量，释放它拥有的资源。进入 pthread_cond_destroy 之前，必须没有在该条件变量上等待的线程。
(5)条件变量函数不是异步信号安全的，不应当在信号处理程序中进行调用。特别要注意，如果在信号处理程序中调用 pthread_cond_signal 或pthread_cond_boardcast 函数，可能导致调用线程死锁。
示例程序1
#include <stdio.h>
#include <pthread.h>
#include "stdlib.h"
#include "unistd.h"
pthread_mutex_t mutex
pthread_cond_t cond
void hander(void *arg)
{
free(arg)
(void)pthread_mutex_unlock(&mutex)
}
void *thread1(void *arg)
{
pthread_cleanup_push(hander, &mutex)
while(1)
{
printf("thread1 is running\n")
pthread_mutex_lock(&mutex)
pthread_cond_wait(&cond,&mutex)
printf("thread1 applied the condition\n")
pthread_mutex_unlock(&mutex)
sleep(4)
}
pthread_cleanup_pop(0)
}
void *thread2(void *arg)
{
while(1)
{
printf("thread2 is running\n")
pthread_mutex_lock(&mutex)
pthread_cond_wait(&cond,&mutex)
printf("thread2 applied the condition\n")
pthread_mutex_unlock(&mutex)
sleep(1)
}
}
int main()
{
pthread_t thid1,thid2
printf("condition variable study!\n")
pthread_mutex_init(&mutex,NULL)
pthread_cond_init(&cond,NULL)
pthread_create(&thid1,NULL,thread1,NULL)
pthread_create(&thid2,NULL,thread2,NULL)
sleep(1)
do
{
pthread_cond_signal(&cond)
}while(1)
sleep(20)
pthread_exit(0)
return 0
}
示例程序2：
#include <pthread.h>
#include <unistd.h>
#include "stdio.h"
#include "stdlib.h"
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER
struct node
{
int n_number
struct node *n_next
} *head = NULL
/*[thread_func]*/
static void cleanup_handler(void *arg)
{
printf("Cleanup handler of second thread./n")
free(arg)
(void)pthread_mutex_unlock(&mtx)
}
static void *thread_func(void *arg)
{
struct node *p = NULL
pthread_cleanup_push(cleanup_handler, p)
while (1)
{
//这个mutex主要是用来保证pthread_cond_wait的并发性
pthread_mutex_lock(&mtx)
while (head == NULL)
{
//这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何
//这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线
//程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。
//这个时候，应该让线程继续进入pthread_cond_wait
// pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx，
//然后阻塞在等待对列里休眠，直到再次被唤醒（大多数情况下是等待的条件成立
//而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx)，再读取资源
//用这个流程是比较清楚的/*block-->unlock-->wait() return-->lock*/
pthread_cond_wait(&cond, &mtx)
p = head
head = head->n_next
printf("Got %d from front of queue/n", p->n_number)
free(p)
}
pthread_mutex_unlock(&mtx)//临界区数据 *** 作完毕，释放互斥锁
}
pthread_cleanup_pop(0)
return 0
}
int main(void)
{
pthread_t tid
int i
struct node *p
//子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而
//不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大
pthread_create(&tid, NULL, thread_func, NULL)
sleep(1)
for (i = 0i <10i++)
{
p = (struct node*)malloc(sizeof(struct node))
p->n_number = i
pthread_mutex_lock(&mtx)//需要 *** 作head这个临界资源，先加锁，
p->n_next = head
head = p
pthread_cond_signal(&cond)
pthread_mutex_unlock(&mtx)//解锁
sleep(1)
}
printf("thread 1 wanna end the line.So cancel thread 2./n")
//关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，子线程会在最近的取消点，退出
//线程，而在我们的代码里，最近的取消点肯定就是pthread_cond_wait()了。
pthread_cancel(tid)
pthread_join(tid, NULL)
printf("All done -- exiting/n")
return 0
}
3）信号量
如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。
信号量函数的名字都以"sem_"打头。线程使用的基本信号量函数有四个。
#include <semaphore.h>
int sem_init (sem_t *sem , int pshared, unsigned int value)
这是对由sem指定的信号量进行初始化，设置好它的共享选项（linux 只支持为0，即表示它是当前进程的局部信号量），然后给它一个初始值VALUE。
两个原子 *** 作函数：
int sem_wait(sem_t *sem)
int sem_post(sem_t *sem)
这两个函数都要用一个由sem_init调用初始化的信号量对象的指针做参数。
sem_post：给信号量的值加1；
sem_wait:给信号量减1；对一个值为0的信号量调用sem_wait,这个函数将会等待直到有其它线程使它不再是0为止。
int sem_destroy(sem_t *sem)
这个函数的作用是再我们用完信号量后都它进行清理。归还自己占有的一切资源。
示例代码：
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include <errno.h>
#define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__)return}
typedef struct _PrivInfo
{
sem_t s1
sem_t s2
time_t end_time
}PrivInfo
static void info_init (PrivInfo* thiz)
static void info_destroy (PrivInfo* thiz)
static void* pthread_func_1 (PrivInfo* thiz)
static void* pthread_func_2 (PrivInfo* thiz)
int main (int argc, char** argv)
{
pthread_t pt_1 = 0
pthread_t pt_2 = 0
int ret = 0
PrivInfo* thiz = NULL
thiz = (PrivInfo* )malloc (sizeof (PrivInfo))
if (thiz == NULL)
{
printf ("[%s]: Failed to malloc priv./n")
return -1
}
info_init (thiz)
ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz)
if (ret != 0)
{
perror ("pthread_1_create:")
}
ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz)
if (ret != 0)
{
perror ("pthread_2_create:")
}
pthread_join (pt_1, NULL)
pthread_join (pt_2, NULL)
info_destroy (thiz)
return 0
}
static void info_init (PrivInfo* thiz)
{
return_if_fail (thiz != NULL)
thiz->end_time = time(NULL) + 10
sem_init (&thiz->s1, 0, 1)
sem_init (&thiz->s2, 0, 0)
return
}
static void info_destroy (PrivInfo* thiz)
{
return_if_fail (thiz != NULL)
sem_destroy (&thiz->s1)
sem_destroy (&thiz->s2)
free (thiz)
thiz = NULL
return
}
static void* pthread_func_1 (PrivInfo* thiz)
{
return_if_fail (thiz != NULL)
while (time(NULL) <thiz->end_time)
{
sem_wait (&thiz->s2)
printf ("pthread1: pthread1 get the lock./n")
sem_post (&thiz->s1)
printf ("pthread1: pthread1 unlock/n")
sleep (1)
}
return
}
static void* pthread_func_2 (PrivInfo* thiz)
{
return_if_fail (thiz != NULL)
while (time (NULL) <thiz->end_time)
{
sem_wait (&thiz->s1)
printf ("pthread2: pthread2 get the unlock./n")
sem_post (&thiz->s2)
printf ("pthread2: pthread2 unlock./n")
sleep (1)
}
return
}
通 过执行结果后，可以看出，会先执行线程二的函数，然后再执行线程一的函数。它们两就实现了同步
管道用于有学园关系的进程之间。
管道的pipe 系统调用实际上就是创建出来两个文件描述符。
当父进P1程创建出 fd[2] 时，子进程P2 会继承父进程的所有，所以也会得到pipe 的 2个 文件描述符。
所以毫无瓜葛的两个进程，一定不会访问到彼此的pipe。无法用管道进行通信。
管道一般是单工的。f[0]读，f[1]写
管道也可以适用于 兄弟进程（只要有血缘即可）。由于管道是单工的，当两个进程之间需要双向通信，则需要两跟管道。
执行
ctrl-c(2号信号) + SIGUSR1 信号 绑了一个新函数。则 ctrl-c 无效。
查看进程的信号
号信号被捕获。
将2号信号忽略掉
9号信号 kill 和19号信号 stop 不能乱搞，只能用缺省。
其它信号甚至段信号也都可以捕获。
改变程序的执行现场，修改PC指针，有些像goto，只不过返回非0值
运行结果
making segment fault
after segment fault
程序不会死。
如果不忽略 page fault
则会产生 core dump.
不停的给data 赋值，同时每隔1s会有信号进来，打印 data的值。
理论上打印出来的结果同时为0，同时为1
但并非如此，是 0，1，交替随机的。
signal 异步的，随时都可以进来，所以打印出来的结果，并不是我想要的。
信号对于应用程序来说，很像中断对于内核，都是访问临界区数据
信号被屏蔽，延后执行。
写多线程的程序时，不要以为只有线程之间有竞争，其实信号也会有竞争
system v 的IPC 年代有些久远。
有血缘关系的进程 key_t 都是相同的。
Key 是私有key IPV PRIVATE
可能用消息队列，可能用共享内存，可能用信号量进行通讯。
利用 _pathname 路径，约定好一条路径。和tcp/ip地址很像，来生成一个key_t key, 用msg_get shm_get 得到共享内存or 信号量。
int id 可以理解为文件描述符 fd。
其中Sys V 的共享内存 最为常用。
一定要检查路径，如果仅仅有2个进程，你没有创建路径，两者都是 -1（相当于大家约定好了），那当然能通信拉。但更多的进程出现，则会有问题。
一定要检查返回值
依然依靠key，但是api 实在是太挫了。P&V *** 作都是 semop. (posix 的 ipc跟为简洁)
POSIX 共享内存当然也需要一个名字，但并不是路径。
无论读进程还是写进程，都需要传入相同的名字。
如果是unbuntu 会在以下路径生成文件
其实 2和3 是1 的符号链接。 只要保证是一个就能互相通信
关键点，mmap 内存的属性修改为 private 后，产生写时copy，虚拟地址一样，但是物理地址已经不同了
当然 如果子进程修改了程序背景，执行了 exec，那么完全不一样了，直接修改了内存逻辑。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）