Linux C语言编程 之 线程同步机制

线程函数：

#include <pthread.h>;
int pthread_create(pthread_t *thread,pthread_attr_t *attr,void *(*start_routine)(void *),void *arg);
void pthread_exit(void *retval);
int pthread_join(pthread *thread,void **thread_return);
pthread_create 创建一个线程, thread 是用来表明创建线程的ID,
attr 指出线程创建时候的属性,我们用NULL 来表明使用缺省属性.
start_routine 函数指针是线程创建成功后开始执行的函数,arg是这个函数的唯一一个参数.表明传递给 start_routine 的参数.

pthread_exit 函数和exit 函数类似用来退出线程.这个函数结束线程,释放函数的资源,并在最后阻塞,

直到其他线程使用pthread_join 函数等待它.然后将*retval 的值传递给**thread_return.

由于这个函数释放所有的函数资源,所以retval 不能够指向函数的局部变量. 

pthread_join 和wait 调用一样用来等待指定的线程. 

linux C线程间同步机制有很多：

互斥锁基本操作函数：
初始化互斥锁： pthread_mutex_init();
销毁互斥锁： pthread_mutex_destroy();
阻塞申请互斥锁： pthread_mutex_lock();
释放互斥锁: pthread_mutex_unlock();
非阻塞申请互斥锁： pthread_mutex_trylock();

条件变量基本函数：
初始化条件变量： pthread_cond_init();
阻塞等待条件变量： pthread_cond_wait();
通知等待该条件变量的第一个线程：pthread_cond_signal();
在指定的时间之内阻塞等待条件变量：pthread_cond_timedwait();
通知等待该条件变量的所有线程：pthread_cond_broadcast();
销毁条件变量： pthread_cond_destory();

读写锁基本操作：
初始化读写锁： pthread_rwlock_init();
阻塞申请读锁： pthread_rwlock_rdlock();
非阻塞申请读锁： pthread_rwlock_tryrdlock();
阻塞申请写锁： pthread_rwlock_wrlock();
非阻塞申请写锁： pthread_rwlock_trywrlock();
释放锁： pthread_rwlock_unlock();
销毁锁： pthread_rwlock_destroy();

无名信号量基本操作：(值为1时可以作为互斥量)
初始化信号量： sem_init(sem_t*sem,int pshared,unsigned int value);
销毁信号量： sem_destroy(sem_t*sem);
释放信号量（+1）： sem_post(sem_t*sem);
阻塞等待信号量(-1)： sem_wait(sem_t*sem);
非阻塞等待信号量： sem_trywait(sem_t*sem);
获取当前信号量值： sem_getvalue(sem_t*sem);

定时等待信号量： sem_timedwait(sem_t*sem,sturct timespec*abs_timeout);

一，互斥锁mutex

1.创建互斥锁
静态方式: pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER
动态方式: int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);

2.注销一个互斥锁: int pthread_mutex_destroy(pthread_mutex_t *mutex);
互斥锁属性:当前（glibc2.2.3,linuxthreads0.9）有四个值可供选择：

PTHREAD_MUTEX_TIMED_NP:这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。

PTHREAD_MUTEX_RECURSIVE_NP :嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。
PTHREAD_MUTEX_ERRORCHECK_NP :检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与 PTHREAD_MUTEX_TIMED_NP 类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。
PTHREAD_MUTEX_ADAPTIVE_NP :适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。


3.锁操作:主要包括加锁pthread_mutex_lock()、解锁pthread_mutex_unlock()和测试加锁pthread_mutex_trylock()三个.

不论哪种类型的锁，都不可能被两个不同的线程同时得到，而必须等待解锁。
对于普通锁和适应锁类型，解锁者可以是同进程内任何线程；
而检错锁则必须由加锁者解锁才有效，否则返回EPERM；
对于嵌套锁，文档和实现要求必须由加锁者解锁，但实验结果表明并没有这种限制，这个不同目前还没有得到解释。
在同一进程中的线程，如果加锁后没有解锁，则任何其他线程都无法再获得锁。


二，条件变量: 条件变量是利用线程间共享的全局变量进行同步的一种机制.
主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；
另一个线程使"条件成立"（给出条件成立信号）。
为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。


1.创建互斥锁
静态方式:pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
动态方式:int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
注销一个互斥锁:int pthread_cond_destroy(pthread_cond_t *cond);
 
2.等待和激发
无条件等待 ：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);
无论哪种等待方式，都必须和一个互斥锁配合，
以防止多个线程同时请求pthread_cond_wait()（或pthread_cond_timedwait()，下同）的竞争条件（Race Condition）。
mutex互斥锁必须是普通锁（PTHREAD_MUTEX_TIMED_NP）或者适应锁（PTHREAD_MUTEX_ADAPTIVE_NP），
且在调用pthread_cond_wait()前必须由本线程加锁（pthread_mutex_lock()），
而在更新条件等待队列以前，mutex保持锁定状态，并在线程挂起进入等待前解锁。
在条件满足从而离开pthread_cond_wait()之前，mutex将被重新加锁，以与进入pthread_cond_wait()前的加锁动作对应。


3.激发条件有两种形式:
pthread_cond_signal()激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个；
pthread_cond_broadcast()则激活所有等待线程。


以下示例集中演示了互斥锁和条件变量的结合使用，以及取消对于条件等待动作的影响。
在例子中，有两个线程被启动，并等待同一个条件变量，如果不使用退出回调函数（见范例中的注释部分），
则tid2将在pthread_mutex_lock()处永久等待。

如果使用回调函数，则tid2的条件等待及主线程的条件激发都能正常工作。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t mutex;
pthread_cond_t  cond;
void * child1(void *arg)
{
        pthread_cleanup_push(pthread_mutex_unlock,&mutex);  /* comment 1 */
        while(1){
printf("thread 1 get running \n");
printf("thread 1 pthread_mutex_lock returns %d\n",
pthread_mutex_lock(&mutex));
pthread_cond_wait(&cond,&mutex);
printf("thread 1 condition applied\n");
pthread_mutex_unlock(&mutex);
sleep(5);
}
        pthread_cleanup_pop(0);     /* comment 2 */
}
void *child2(void *arg)
{
        while(1){
            sleep(3);               /* comment 3 */
            printf("thread 2 get running.\n");
printf("thread 2 pthread_mutex_lock returns %d\n",
pthread_mutex_lock(&mutex));
pthread_cond_wait(&cond,&mutex);
printf("thread 2 condition applied\n");
pthread_mutex_unlock(&mutex);
sleep(1);
        }
}
int main(void)
{
        int tid1,tid2;
        printf("hello, condition variable test\n");
        pthread_mutex_init(&mutex,NULL);
        pthread_cond_init(&cond,NULL);
        pthread_create(&tid1,NULL,child1,NULL);
        pthread_create(&tid2,NULL,child2,NULL);
        do{
sleep(2);                   /* comment 4 */
pthread_cancel(tid1);       /* comment 5 */
sleep(2);                   /* comment 6 */
pthread_cond_signal(&cond);
}while(1);  
        sleep(100);
        pthread_exit(0);
}
如果不做注释5的pthread_cancel()动作，即使没有那些sleep()延时操作，child1和child2都能正常工作。
注释3和注释4的延迟使得child1有时间完成取消动作，从而使child2能在child1退出之后进入请求锁操作。
如果没有注释1和注释2的回调函数定义，系统将挂起在child2请求锁的地方；
而如果同时也不做注释3和注释4的延时，child2能在child1完成取消动作以前得到控制，从而顺利执行申请锁的操作，但却可能挂起在pthread_cond_wait()中，因为其中也有申请mutex的操作。

三：信号灯
信号灯与互斥锁和条件变量的主要不同在于"灯"的概念，灯亮则意味着资源可用，灯灭则意味着不可用。如果说后两中同步方式侧重于"等待"操作，即资源不可用的话，信号灯机制则侧重于点灯，即告知资源可用；没有等待线程的解锁或激发条件都是没有意义的，而没有等待灯亮的线程的点灯操作则有效，且能保持灯亮状态。当然，这样的操作原语也意味着更多的开销。

信号灯的应用除了灯亮/灯灭这种二元灯以外，也可以采用大于1的灯数，以表示资源数大于1，这时可以称之为多元灯。
1． 创建和注销
POSIX信号灯标准定义了有名信号灯和无名信号灯两种，但LinuxThreads的实现仅有无名灯，同时有名灯除了总是可用于多进程之间以外，在使用上与无名灯并没有很大的区别，因此下面仅就无名灯进行讨论。

创建信号：int sem_init(sem_t *sem, int pshared, unsigned int value) 
其中value为信号灯的初值，
pshared表示是否为多进程共享而不仅仅是用于一个进程。
LinuxThreads没有实现多进程共享信号灯，因此所有非0值的pshared输入都将使sem_init()返回-1，且置errno为ENOSYS。
初始化好的信号灯由sem变量表征，用于以下点灯、灭灯操作。

注销信号：int sem_destroy(sem_t * sem) 
被注销的信号灯sem要求已没有线程在等待该信号灯，否则返回-1，且置errno为EBUSY。
除此之外，LinuxThreads的信号灯注销函数不做其他动作。

2． 点灯和灭灯
int sem_post(sem_t * sem)；//+1
点灯操作将信号灯值原子地加1，表示增加一个可访问的资源。
int sem_wait(sem_t * sem);//-1
int sem_trywait(sem_t * sem)
sem_wait()为等待灯亮操作，等待灯亮（信号灯值大于0），然后将信号灯原子地减1，并返回。
sem_trywait()为sem_wait()的非阻塞版，如果信号灯计数大于0，则原子地减1并返回0，否则立即返回-1，errno置为EAGAIN。
3.获取灯值
int sem_getvalue(sem_t * sem, int * sval)
读取sem中的灯计数，存于*sval中，并返回0。

四：异步信号：
由于LinuxThreads是在核外使用核内轻量级进程实现的线程，所以基于内核的异步信号操作对于线程也是有效的。
但同时，由于异步信号总是实际发往某个进程，所以无法实现POSIX标准所要求的"信号到达某个进程，
然后再由该进程将信号分发到所有没有阻塞该信号的线程中"原语，而是只能影响到其中一个线程。

POSIX异步信号同时也是一个标准C库提供的功能，主要包括：
信号集管理：sigemptyset(),sigfillset(),sigaddset(),sigdelset(),sigismember()等，
信号处理函数安装：sigaction();
信号阻塞控制：sigprocmask();
被阻塞信号查询：sigpending();
信号等待：sigsuspend();
发送信号的：kill()；

LinuxThreads围绕线程封装了sigaction()和raise()，
下面介绍LinuxThreads中扩展的异步信号函数，包括pthread_sigmask()、pthread_kill()和sigwait()三个函数。
毫无疑问，所有POSIX异步信号函数对于线程都是可用的。

int pthread_sigmask(int how, const sigset_t *newmask, sigset_t *oldmask) 
设置线程的信号屏蔽码，语义与sigprocmask()相同，但对不允许屏蔽的Cancel信号和不允许响应的Restart信号进行了保护。
被屏蔽的信号保存在信号队列中，可由sigpending()函数取出。

int pthread_kill(pthread_t thread, int signo) 
向thread号线程发送signo信号。实现中在通过thread线程号定位到对应进程号以后使用kill()系统调用完成发送。

int sigwait(const sigset_t *set, int *sig) 
挂起线程，等待set中指定的信号之一到达，并将到达的信号存入*sig中。
POSIX标准建议在调用sigwait()等待信号以前，进程中所有线程都应屏蔽该信号，以保证仅有sigwait()的调用者获得该信号，
因此，对于需要等待同步的异步信号，总是应该在创建任何线程以前调用pthread_sigmask()屏蔽该信号的处理。
而且，调用sigwait()期间，原来附接在该信号上的信号处理函数不会被调用。

如果在等待期间接收到Cancel信号，则立即退出等待，也就是说sigwait()被实现为取消点。

五：其他同步方式
除了上述讨论的同步方式以外，其他很多进程间通信手段对于LinuxThreads也是可用的，
比如基于文件系统的IPC（管道、Unix域Socket等）、消息队列（Sys.V或者Posix的）、System V的信号灯等。
只有一点需要注意，LinuxThreads在核内是作为共享存储区、共享文件系统属性、共享信号处理、共享文件描述符的独立进程看待的。