线程间通信机制

最新推荐文章于 2023-07-18 15:03:03 发布
最新推荐文章于 2023-07-18 15:03:03 发布
阅读量1.3k 收藏
点赞数
分类专栏： Linux programming

一、Linux系统中的线程间通信方式主要以下几种:

*  锁机制：包括互斥锁、条件变量、读写锁

  互斥锁提供了以排他方式防止数据结构被并发修改的方法。

读写锁允许多个线程同时读共享数据，而对写操作是互斥的。

  条件变量可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。

*  信号量机制(Semaphore)：包括无名线程信号量和命名线程信号量

*  信号机制(Signal)：类似进程间的信号处理

二、详解

1、互斥锁通信机制

基本原理

互斥锁以排他方式防止共享数据被并发访问,互斥锁是一个二元变量,状态为开(0)和关(1),将某个共享资源与某个互斥锁逻辑上绑定之后,对该资源的访问操作如下:

(1)在访问该资源之前需要首先申请互斥锁,如果锁处于开状态,则申请得到锁并立即上锁(关),防止其他进程访问资源,如果锁处于关,则默认阻塞等待.

(2)只有锁定该互斥锁的进程才能释放该互斥锁.

互斥量类型声明为pthread_mutex_t数据类型，在<bits/pthreadtypes.h>中有具体的定义。

互斥量初始化和销毁

在使用互斥锁之前需要定义互斥锁(全局变量),定义代码:

通过锁机制实现线程间的同步。同一时刻只允许一个线程执行一个关键部分的代码。

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下互斥锁不占用内存资源

pthread_mutex lock;

/* Initialize a mutex.  */
int pthread_mutex_init (pthread_mutex_t *__mutex,\      // 指向要初始化的互斥锁的指针
                        __const pthread_mutexattr_t *__mutexattr); // 指向互斥锁属性对象的指针,设null为默认属性

/* Destroy a mutex.  */
int pthread_mutex_destroy (pthread_mutex_t *__mutex);

上面两个函数分别由于互斥量的初始化和销毁。

如果互斥量是静态分配的，可以通过常量进行初始化，如下：

#define PTHREAD_MUTEX_INITIALIZER {{0, }}  // 系统定义的,无需声明
pthread_mutex_t mlock = PTHREAD_MUTEX_INITIALIZER;

当然也可以通过pthread_mutex_init()进行初始化。对于动态分配的互斥量由于不能直接赋值进行初始化就只能采用这种方式进行初始化，pthread_mutex_init()的第二个参数是互斥量的属性，如果采用默认的属性设置，可以传入NULL。

当不在需要使用互斥量时，需要调用pthread_mutex_destroy()销毁互斥量所占用的资源。

互斥量的属性设置

/* 初始化互斥量属性对象 */
int pthread_mutexattr_init (pthread_mutexattr_t *__attr);

/* 销毁互斥量属性对象  */
int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr);

/* 获取互斥量属性对象在进程间共享与否的标志 */
int pthread_mutexattr_getpshared (__const pthread_mutexattr_t *__restrict __attr, \
                                   int *__restrict __pshared);

/* 设置互斥量属性对象，标识在进程间共享与否 */
int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, int __pshared);

互斥量在初始化的时候pthread_mutex_init的第二个参数是互斥量的属性，如果为NULL空指针，那么就使用默认属性。

互斥量属性的数据类型为pthread_mutexattr_t，它的初始化和销毁和互斥量类似。一旦互斥量属性对象被初始化后，就可以通过调用不同的函数启用或禁止特定的属性。这里列出了一个设置特定属性的函数：pthread_mutexattr_setpshared，可以用于指定互斥量在不同进程间共享，这样可以通过互斥量来同步不同的进程，当然前提是该互斥量位于进程间的共享内存区。

pthread_mutexattr_setpshared()函数的第二个参数__pshared用于设定是否进程间共享，其值可以是PTHREAD_PROCESS_PRIVATE或PTHREAD_PROCESS_SHARED，后者是设置进程间共享。

下面是使互斥量可以在进程间共享的大致过程：

pthread_mutex_t *pSharedMutex;  //指向共享内存区的互斥量
pthread_mutexattr_t mutexAttr;  //互斥量属性

pSharedMutex = /*一个指向共享内存区的指针*/;

pthread_mutexattr_init(&mutexAttr);
pthread_mutexattr_setpshared(&mutexAttr, PTHREAD_PROCESS_SHARED);
pthread_mutex_init(pSharedMutex, &mutexAttr);

互斥量的申请使用

/* Try locking a mutex.  */
int pthread_mutex_trylock (pthread_mutex_t *__mutex);

/* Lock a mutex.  */
int pthread_mutex_lock (pthread_mutex_t *__mutex);

/* Unlock a mutex.  */
int pthread_mutex_unlock (pthread_mutex_t *__mutex);
这几个函数都很简单，通过pthread_mutex_lock()函数获得访问共享资源的权限，如果已经有其他线程锁住互斥量，那么该函数会是线程阻塞指定该互斥量解锁为止。 pthread_mutex_trylock()是对应的非阻塞函数，如果互斥量已被占用，它会返回一个EBUSY错误。访问完共享资源后，一定要通过pthread_mutex_unlock() 函数，释放占用的互斥量。允许其他线程访问该资源。

这里要强调的是：互斥量是用于上锁的，不能用于等待。

简单说就是，互斥量的使用流程应该是：线程占用互斥量，然后访问共享资源，最后释放互斥量。而不应该是：线程占用互斥量，然后判断资源是否可用，如果不可用，释放互斥量，然后重复上述过程。这种行为称为轮转或轮询，是一种浪费CPU时间的行为。

应用示例

下面的程序使用了两个同进程的线程,一个线程负责从标准设备读入数据存储在共享数据区,另一个负责将读入的数据输出到标准设备.其实是一个生产者消费者的变形.

  1. 处理输入操作的线程在接受用户信息的时候必须互斥使用该资源,不能被打断,阻塞其他线程的进行
  2. 输出线程也不能被打断,需要先锁定互斥锁,操作完成后释放,
  3. 程序结束,销毁互斥锁.

代码如下:

/*************************************************************************
> File Name: pthread_exp.c
> Author:SuooL 
> Mail:1020935219@qq.com || hu1020935219@gmail.com
> Website:http://blog.csdn.net/suool | http://suool.net
> Created Time: 2014年08月15日 星期三 08时42分45秒
> Description: 
************************************************************************/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>

void *thread_function(void *arg);

pthread_mutex_t work_mutex;     // 定义全局互斥锁对象

#define WORK_SIZE 1024          
char work_area[WORK_SIZE];      // 全局共享数据区
int time_to_exit = 0;           // 标志变量

// main函数
int main(int argc,char *argv[]) 
{
    int res;
    pthread_t a_thread;           // 线程
    void *thread_result;
    res = pthread_mutex_init(&work_mutex, NULL); //init mutex 初始化互斥锁
    if (res != 0) 
    {
        perror("Mutex initialization failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_create(&a_thread, NULL, thread_function, NULL);//create new thread
    if (res != 0) 
    {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    pthread_mutex_lock(&work_mutex);			//lock the mutex,before get the input
    printf("Input some text. Enter 'end' to finish\n");
    while(!time_to_exit) 
    {
        fgets(work_area, WORK_SIZE, stdin);		//get a string from stdin
        pthread_mutex_unlock(&work_mutex);		//unlock the mutex
        while(1) 
        {
            pthread_mutex_lock(&work_mutex);	//lock the mutex
            if (work_area[0] != '\0')              // check out if the info input has been output
            {
                pthread_mutex_unlock(&work_mutex);	//unlock the mutex
                sleep(1);
            }
            else                                // if has been output, break and goto next iput
            {
                break;
            }
        }
    }
    pthread_mutex_unlock(&work_mutex);          // unlock the mutex 
    printf("\nWaiting for thread to finish...\n");
    res = pthread_join(a_thread, &thread_result);    // wait for the other pthread end
    if (res != 0) 
    {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    printf("Thread joined\n");
    pthread_mutex_destroy(&work_mutex);         // destory the mutex
    exit(EXIT_SUCCESS);
}

// the pthread run function
void *thread_function(void *arg) 
{
    sleep(1);
    pthread_mutex_lock(&work_mutex);  // lock the mutex 抢占资源
    while(strncmp("end", work_area, 3) != 0)   // 判断是否为结束信息
    {
        printf("You input %d characters\n", strlen(work_area) -1); // 输出输入信息
        printf("the characters is %s",work_area);
        work_area[0] = '\0';         // 设置数据区,表示输入已被输出
        pthread_mutex_unlock(&work_mutex);   // 解锁
        sleep(1);
        pthread_mutex_lock(&work_mutex);     // 上锁
        while (work_area[0] == '\0' )        // 判断是否被输出
        {                 // 如果是\0则没有输入,等待主进程输入
         pthread_mutex_unlock(&work_mutex); // 解锁
         sleep(1);                            // 等待
         pthread_mutex_lock(&work_mutex);   // 上锁,再次检测
        }
    }
    time_to_exit = 1;             // 设置主线程退出信号
    work_area[0] = '\0';           // 标志输出
    pthread_mutex_unlock(&work_mutex);    // 世界所
    pthread_exit(0);           // 线程退出
}

运行结果:

编程,多线程,笔记,互斥,学习0

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

 

  1. #include <stdio.h>
  2. #include <pthread.h>
  3. #include "stdlib.h"
  4. #include "unistd.h"
  6. pthread_mutex_t mutex;
  7. pthread_cond_t cond;
  9. void hander(void *arg)
  10. {
  11.     free(arg); 
  12.     (void)pthread_mutex_unlock(&mutex);
  13. }
  15. void *thread1(void *arg)
  16. {
  17.      pthread_cleanup_push(hander, &mutex); 
  18.      while(1) 
  19.      { 
  20.          printf("thread1 is running\n"); 
  21.          pthread_mutex_lock(&mutex); 
  22.          pthread_cond_wait(&cond,&mutex); 
  23.          printf("thread1 applied the condition\n"); 
  24.          pthread_mutex_unlock(&mutex); 
  25.          sleep(4); 
  26.      } 
  27.      pthread_cleanup_pop(0); 
  28. } 
  30. void *thread2(void *arg)
  31. { 
  32.     while(1) 
  33.     { 
  34.         printf("thread2 is running\n"); 
  35.         pthread_mutex_lock(&mutex); 
  36.         pthread_cond_wait(&cond,&mutex); 
  37.         printf("thread2 applied the condition\n"); 
  38.         pthread_mutex_unlock(&mutex); 
  39.         sleep(1); 
  40.     }
  41. }
  43. int main()
  44. {
  45.      pthread_t thid1,thid2; 
  46.      printf("condition variable study!\n"); 
  47.      pthread_mutex_init(&mutex,NULL); 
  48.      pthread_cond_init(&cond,NULL); 
  49.      pthread_create(&thid1,NULL,thread1,NULL); 
  50.      pthread_create(&thid2,NULL,thread2,NULL); 
  51.      sleep(1); 
  52.      do 
  53.      { 
  54.          pthread_cond_signal(&cond); 
  55.      }while(1); 
  56.      sleep(20); 
  57.      pthread_exit(0); 
  58.      return 0;
  59. }

示例程序2：

  1. #include <pthread.h> 
  2. #include <unistd.h> 
  3. #include "stdio.h"
  4. #include "stdlib.h"
  6. static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; 
  7. static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 
  9. struct node 
  10. {
  11.      int n_number; 
  12.      struct node *n_next; 
  13. } *head = NULL; 
  15. /*[thread_func]*/ 
  16. static void cleanup_handler(void *arg) 
  17. {
  18.      printf("Cleanup handler of second thread./n"); 
  19.      free(arg); 
  20.      (void)pthread_mutex_unlock(&mtx); 
  21. } 
  23. static void *thread_func(void *arg) 
  24. {
  25.      struct node *p = NULL; 
  26.      pthread_cleanup_push(cleanup_handler, p); 
  27.      while (1) 
  28.      { 
  29.          //这个mutex主要是用来保证pthread_cond_wait的并发性
  30.          pthread_mutex_lock(&mtx); 
  31.          while (head == NULL) 
  32.          { 
  33.          //这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何
  34.          //这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线 
  35.          //程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。 
  36.          //这个时候，应该让线程继续进入pthread_cond_wait 
  37.          // pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx， 
  38.          //然后阻塞在等待对列里休眠，直到再次被唤醒（大多数情况下是等待的条件成立 
  39.          //而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx);，再读取资源 
  40.          //用这个流程是比较清楚的/*block-->unlock-->wait() return-->lock*/ 
  41.          pthread_cond_wait(&cond, &mtx); 
  42.          p = head; 
  43.          head = head->n_next; 
  44.          printf("Got %d from front of queue/n", p->n_number);
  45.          free(p); 
  46.           } 
  47.           pthread_mutex_unlock(&mtx); //临界区数据操作完毕，释放互斥锁 
  48.      } 
  49.      pthread_cleanup_pop(0); 
  50.      return 0; 
  51. } 
  53. int main(void) 
  54. {
  55.      pthread_t tid; 
  56.      int i; 
  57.      struct node *p; 
  58.      //子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而 
  59.      //不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大
  60.      pthread_create(&tid, NULL, thread_func, NULL); 
  61.      sleep(1); 
  62.      for (i = 0; i < 10; i++) 
  63.      { 
  64.          p = (struct node*)malloc(sizeof(struct node)); 
  65.          p->n_number = i; 
  66.          pthread_mutex_lock(&mtx); //需要操作head这个临界资源，先加锁， 
  67.          p->n_next = head; 
  68.          head = p; 
  69.          pthread_cond_signal(&cond); 
  70.          pthread_mutex_unlock(&mtx); //解锁 
  71.          sleep(1); 
  72.      } 
  73.      printf("thread 1 wanna end the line.So cancel thread 2./n"); 
  74.      
  75.      //关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，子线程会在最近的取消点，退出 
  76.      //线程，而在我们的代码里，最近的取消点肯定就是pthread_cond_wait()了。 
  77.      pthread_cancel(tid); 
  78.      pthread_join(tid, NULL); 
  79.      printf("All done -- exiting/n"); 
  80.      return 0; 
  81. }
3、读写锁

读写锁通信机制 

读写锁和互斥量（互斥锁）很类似，是另一种线程同步机制，但不属于POSIX标准，可以用来同步同一进程中的各个线程。当然如果一个读写锁存放在多个进程共享的某个内存区中，那么还可以用来进行进程间的同步.

因为对数据的读写应用中,很多情况都是大量的读操作,而较少有写操作,例如对数据库的访问等,显然这样使用互斥锁会很影响效率,为了满足这样的需求,ＰＯＳＩＸ线提供了读写锁机制．模式如下：

  1. 如果当前进程读数据，其他的进程也可以进行读操作，但不能写操作
  2. 如果当前进程写数据，则所有其它进程阻塞等待

和互斥量不同的是：互斥量会把试图进入已保护的临界区的线程都阻塞；然而读写锁会视当前进入临界区的线程和请求进入临界区的线程的属性来判断是否允许线程进入。

相对互斥量只有加锁和不加锁两种状态，读写锁有三种状态：读模式下的加锁，写模式下的加锁，不加锁。

读写锁的使用规则：

  • 只要没有写模式下的加锁，任意线程都可以进行读模式下的加锁；
  • 只有读写锁处于不加锁状态时，才能进行写模式下的加锁；

    读写锁也称为共享-独占（shared-exclusive）锁，当读写锁以读模式加锁时，它是以共享模式锁住，当以写模式加锁时，它是以独占模式锁住。读写锁非常适合读数据的频率远大于写数据的频率从的应用中。这样可以在任何时刻运行多个读线程并发的执行，给程序带来了更高的并发度。

    定义代码如下：

    pthread_rwlock_t ralock;

    初始化和销毁读写锁

    /* Initialize read-write lock  */
 int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,  // 指向要初始化的读写锁指针
                                __const pthread_rwlockattr_t *__restrict __attr);　// 指向属性对象的指针

/* Destroy read-write lock */
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock);　//返回值：成功返回0，否则返回错误代码

    上面两个函数分别由于读写锁的初始化和销毁。和互斥量，条件变量一样，如果读写锁是静态分配的，可以通过常量进行初始化，如下：

    <span style="font-size:12px;">pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;</span>

    也可以通过pthread_rwlock_init()进行初始化。对于动态分配的读写锁由于不能直接赋值进行初始化，只能通过这种方式进行初始化。pthread_rwlock_init()第二个参数是读写锁的属性，如果采用默认属性，可以传入空指针NULL。

    那么当不在需要使用时及释放（自动或者手动）读写锁占用的内存之前，需要调用 pthread_rwlock_destroy() 进行销毁读写锁占用的资源。

    读写锁的属性设置

    /* 初始化读写锁属性对象 */
int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr);

/* 销毁读写锁属性对象 */
int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr);

/* 获取读写锁属性对象在进程间共享与否的标识*/
int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t * __restrict __attr,
                                          int *__restrict __pshared);

/* 设置读写锁属性对象，标识在进程间共享与否  */
int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, int __pshared);

                                                    返回值：成功返回0，否则返回错误代码
    这个属性设置和互斥量的基本一样，具体可以参考上面的互斥量的设置 互斥量的属性设置

    读写锁的申请使用

    /* 读模式下加锁  */
int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock);

/* 非阻塞的读模式下加锁  */
int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock);

# ifdef __USE_XOPEN2K
/*  限时等待的读模式加锁 */
int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
                                       __const struct timespec *__restrict __abstime);
# endif

/* 写模式下加锁  */
int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock);

/* 非阻塞的写模式下加锁 */
int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock);

# ifdef __USE_XOPEN2K
/* 限时等待的写模式加锁 */
int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
                                       __const struct timespec *__restrict __abstime);
# endif

/* 解锁 */
int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock);

                                                   返回值：成功返回0，否则返回错误代码
    （1）pthread_rwlock_rdlock()系列函数

    pthread_rwlock_rdlock()用于以读模式即共享模式获取读写锁，如果读写锁已经被某个线程以写模式占用，那么调用线程就被阻塞。在实现读写锁的时候可以对共享模式下锁的数量进行限制（目前不知如何限制）。

    pthread_rwlock_tryrdlock()和pthread_rwlock_rdlock()的唯一区别就是，在无法获取读写锁的时候，调用线程不会阻塞，会立即返回，并返回错误代码EBUSY。

    pthread_rwlock_timedrdlock()是限时等待读模式加锁，时间参数struct timespec * __restrict __abstime也是绝对时间，和条件变量的pthread_cond_timedwait()使用基本一致，具体可以参考pthread_cond_timedwait()

    （2）pthread_rwlock_wrlock()系列函数

    pthread_rwlock_wrlock()用于写模式即独占模式获取读写锁，如果读写锁已经被其他线程占用，不论是以共享模式还是独占模式占用，调用线程都会进入阻塞状态。

    pthread_rwlock_trywrlock()在无法获取读写锁的时候，调用线程不会进入睡眠，会立即返回，并返回错误代码EBUSY。

    pthread_rwlock_timedwrlock()是限时等待写模式加锁，也和条件变量的pthread_cond_timedwait()使用基本一致，具体可以参考pthread_cond_timedwait()

    （3）pthread_rwlock_unlock()

    无论以共享模式还是独占模式获得的读写锁，都可以通过调用pthread_rwlock_unlock()函数进行释放该读写锁。

    读写锁应用

    下面的程序使用读写锁实现4个线程读写一段数据.

    其中两个线程读数据,两个线程写数据.

    从结果看出,任意进程写数据的时候,将阻塞所有其他进程的操作,但在某一进程读数据的时候,其他进程仍然可以读得数据.

    编译运行结果如下:

    编程,多线程,笔记,互斥,学习1


    编程,多线程,笔记,互斥,学习2

    代码如下:

    /*************************************************************************
> File Name: pthread_rwlock_exp.c
> Author:SuooL 
> Mail:1020935219@qq.com || hu1020935219@gmail.com
> Website:http://blog.csdn.net/suool | http://suool.net
> Created Time: 2014年08月15日 星期三 09时20分45秒
> Description: 
************************************************************************/
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <bits/pthreadtypes.h>

static pthread_rwlock_t rwlock;     // 读写锁对象

#define WORK_SIZE 1024
char work_area[WORK_SIZE];          // 全局共享数据区
int time_to_exit;                   // 标志变量

// 子线程执行的函数声明
void *thread_function_read_o(void *arg);
void *thread_function_read_t(void *arg);
void *thread_function_write_o(void *arg);
void *thread_function_write_t(void *arg);

// main 函数
int main(int argc,char *argv[]) 
{
    int res;
    pthread_t a_thread,b_thread,c_thread,d_thread;  // 线程定义
    void *thread_result;            // 指针定义

    res=pthread_rwlock_init(&rwlock,NULL);         // 读写锁定义
    if (res != 0) 
    {
        perror("rwlock initialization failed");
        exit(EXIT_FAILURE);
    }
    // 创建子线程
    res = pthread_create(&a_thread, NULL, thread_function_read_o, NULL);//create new thread
    if (res != 0) 
    {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }

    res = pthread_create(&b_thread, NULL, thread_function_read_t, NULL);//create new thread
    if (res != 0) 
    {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_create(&c_thread, NULL, thread_function_write_o, NULL);//create new thread
    if (res != 0)
    {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_create(&d_thread, NULL, thread_function_write_t, NULL);//create new thread
    if (res != 0)
    {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    // 线程等待
    res = pthread_join(a_thread, &thread_result);			
    if (res != 0) 
    {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_join(b_thread, &thread_result);			
    if (res != 0) 
    {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_join(c_thread, &thread_result);			
if (res != 0) 
{
    perror("Thread join failed");
    exit(EXIT_FAILURE);
}
res = pthread_join(d_thread, &thread_result);			
if (res != 0) 
{
    perror("Thread join failed");
    exit(EXIT_FAILURE);
}
// 读写锁销毁
pthread_rwlock_destroy(&rwlock);				
exit(EXIT_SUCCESS);
}

void *thread_function_read_o(void *arg)            // 读线程one
{
    printf("thread read one try to get lock\n");	

    pthread_rwlock_rdlock(&rwlock);          // 获取读写锁
    while(strncmp("end", work_area, 3) != 0)    // 判断是否为输入结束符
    {
        printf("this is thread read one.\n");   // 输出信息
        printf("the characters is %s",work_area);	
        pthread_rwlock_unlock(&rwlock);		// 解锁	
        sleep(2);
        pthread_rwlock_rdlock(&rwlock);			// 获取所
        while (work_area[0] == '\0' ) 		  // 查看数据区开头是否为\0
        {
            pthread_rwlock_unlock(&rwlock);	 // 解锁
            sleep(2);                        // 等待
            pthread_rwlock_rdlock(&rwlock);  // 获取锁,再次查看
        }
    }	
    pthread_rwlock_unlock(&rwlock);	   // 解锁
    time_to_exit=1;  // 设置退出信号
    pthread_exit(0);  // 线程退出
}

 void *thread_function_read_t(void *arg)              // 读线程two,同one
 {
     printf("thread read one try to get lock\n");
     pthread_rwlock_rdlock(&rwlock);
     while(strncmp("end", work_area, 3) != 0) 
     {
         printf("this is thread read two.\n");
         printf("the characters is %s\n",work_area);	
         pthread_rwlock_unlock(&rwlock);			
         sleep(5);
         pthread_rwlock_rdlock(&rwlock);			
         while (work_area[0] == '\0' ) 		 
         {				
             pthread_rwlock_unlock(&rwlock);	
             sleep(5);
             pthread_rwlock_rdlock(&rwlock);	
         }
     }
     pthread_rwlock_unlock(&rwlock);	
     time_to_exit=1;
     pthread_exit(0);
 }

void *thread_function_write_o(void *arg)        // 写线程one
{
    printf("this is write thread one try to get lock\n"); // 输出提示信息
    while(!time_to_exit)               // 是否退出
    {
        pthread_rwlock_wrlock(&rwlock);       // 获取读写锁
        printf("this is write thread one.\nInput some text. Enter 'end' to finish\n");
        fgets(work_area, WORK_SIZE, stdin); // 获取标准输入写到是数据区
        pthread_rwlock_unlock(&rwlock);    // 解锁
        sleep(15); // 等待
    }
    pthread_rwlock_unlock(&rwlock);       // 解锁
    pthread_exit(0);               // 线程退出
}

void *thread_function_write_t(void *arg)  // 写线程two,同one
{
    sleep(10);
    while(!time_to_exit)
    {
        pthread_rwlock_wrlock(&rwlock);
        printf("this is write thread two.\nInput some text. Enter 'end' to finish\n"); 
        fgets(work_area, WORK_SIZE, stdin);
        pthread_rwlock_unlock(&rwlock);
        sleep(20);
    }
    pthread_rwlock_unlock(&rwlock);
    pthread_exit(0);
}
    4、

    信号量

        如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。

        信号量函数的名字都以"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);

        这个函数的作用是再我们用完信号量后都它进行清理。归还自己占有的一切资源。

     

    示例代码：

     

    1. #include <stdlib.h> 
    2. #include <stdio.h> 
    3. #include <unistd.h> 
    4. #include <pthread.h> 
    5. #include <semaphore.h> 
    6. #include <errno.h> 
    7.     
    8. #define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__);return;} 
    9.     
    10. typedef struct _PrivInfo 
    11. { 
    12.   sem_t s1; 
    13.   sem_t s2; 
    14.   time_t end_time; 
    15. }PrivInfo; 
    16.     
    17. static void info_init (PrivInfo* thiz); 
    18. static void info_destroy (PrivInfo* thiz); 
    19. static void* pthread_func_1 (PrivInfo* thiz); 
    20. static void* pthread_func_2 (PrivInfo* thiz); 
    21.     
    22. int main (int argc, char** argv) 
    23. { 
    24.   pthread_t pt_1 = 0; 
    25.   pthread_t pt_2 = 0; 
    26.   int ret = 0; 
    27.   PrivInfo* thiz = NULL; 
    28.       
    29.   thiz = (PrivInfo* )malloc (sizeof (PrivInfo)); 
    30.   if (thiz == NULL) 
    31.   { 
    32.     printf ("[%s]: Failed to malloc priv./n"); 
    33.     return -1; 
    34.   } 
    35.     
    36.   info_init (thiz); 
    37.     
    38.   ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz); 
    39.   if (ret != 0) 
    40.   { 
    41.     perror ("pthread_1_create:"); 
    42.   } 
    43.     
    44.   ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz); 
    45.   if (ret != 0) 
    46.   { 
    47.      perror ("pthread_2_create:"); 
    48.   } 
    49.     
    50.   pthread_join (pt_1, NULL); 
    51.   pthread_join (pt_2, NULL); 
    52.     
    53.   info_destroy (thiz); 
    54.       
    55.   return 0; 
    56. } 
    57.     
    58. static void info_init (PrivInfo* thiz) 
    59. { 
    60.   return_if_fail (thiz != NULL); 
    61.     
    62.   thiz->end_time = time(NULL) + 10; 
    63.       
    64.   sem_init (&thiz->s1, 0, 1); 
    65.   sem_init (&thiz->s2, 0, 0); 
    66.     
    67.   return; 
    68. } 
    69.     
    70. static void info_destroy (PrivInfo* thiz) 
    71. { 
    72.   return_if_fail (thiz != NULL); 
    73.     
    74.   sem_destroy (&thiz->s1); 
    75.   sem_destroy (&thiz->s2); 
    76.     
    77.   free (thiz); 
    78.   thiz = NULL; 
    79.     
    80.   return; 
    81. } 
    82.     
    83. static void* pthread_func_1 (PrivInfo* thiz) 
    84. { 
    85.   return_if_fail (thiz != NULL); 
    86.     
    87.   while (time(NULL) < thiz->end_time) 
    88.   { 
    89.     sem_wait (&thiz->s2); 
    90.     printf ("pthread1: pthread1 get the lock./n"); 
    91.     
    92.     sem_post (&thiz->s1); 
    93.     printf ("pthread1: pthread1 unlock/n"); 
    94.     
    95.     sleep (1); 
    96.   } 
    97.     
    98.   return; 
    99. } 
    100.     
    101. static void* pthread_func_2 (PrivInfo* thiz) 
    102. { 
    103.   return_if_fail (thiz != NULL); 
    104.     
    105.   while (time (NULL) < thiz->end_time) 
    106.   { 
    107.     sem_wait (&thiz->s1); 
    108.     printf ("pthread2: pthread2 get the unlock./n"); 
    109.     
    110.     sem_post (&thiz->s2); 
    111.     printf ("pthread2: pthread2 unlock./n"); 
    112.     
    113.     sleep (1); 
    114.   } 
    115.     
    116.   return; 
    117. }

    通 过执行结果后，可以看出，会先执行线程二的函数，然后再执行线程一的函数。它们两就实现了同步。在上大学的时候，虽然对这些概念知道，可都没有实践过，所 以有时候时间一久就会模糊甚至忘记，到了工作如果还保持这么一种状态，那就太可怕了。虽然现在外面的技术在不断的变化更新，可是不管怎么变，其核心技术还 是依旧的，所以我们必须要打好自己的基础，再学习其他新的知识，那时候再学新的知识也会觉得比较简单的。



lanmolei814
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程是如何通讯的？
javacn_site的博客
05-26 1622
线程通讯指的是多个线程之间通过共享内存或消息传递等方式来协调和同步它们的执行。在多线程编程中，通常会出现多个线程需要共同完成某个任务的情况，这时就需要线程之间进行通讯，以保证任务能够顺利地执行。线程通讯的实现方式主要有以下两种：共享内存：多个线程可以访问同一个共享内存区域，通过读取和写入内存中的数据来进行通讯和同步。消息传递：多个线程之间通过消息队列、管道、信号量等机制来传递信息和同步状态。
线程的通信机制
尼尧Nier的博客
12-01 739
本篇为 [并发与多线程系列] 的第三篇，对应Java知识体系脑图中的 并发与多线程 模块。 这一系列将对Java中并发与多线程的内容来展开。 线程的通信机制线程的通信机制线程通信的几种方式Object.wait 与 Object.notify/notifyAllwait与虚假唤醒wait 的使用范围notify/notifyAll 随机唤醒LockSupport.park 与 LockSupport.unparkLockSupport 中的 blocker避免死锁的特性：不严格的执行顺序LockSuppo
线程间通讯（几种常见的通讯机制，以及实例）
bigger_belief的博客
07-18 5348
介绍线程间通讯的几种方式，以及一些实例
面试官-说一说线程间通信的几种方式
1999的博客
09-29 1398
线程间通信的几种方式1. volatile和synchronized关键字2. 等待/通知机制3. 管道输入/输出流4.Thread.join()5. ThreadLocal 当线程启动时，每个线程都会有自己的栈空间，那么如何让线程间进行通信呢介绍下面几种方式 1. volatile和synchronized关键字 volatile 保证了修饰字段的可见性，可以利用 volatile 关键字 修饰一个boolean 变量 控制多个线程之间的执行的业务逻辑，但是过多的使用 volatile 时不必要的，他会
线程间的通信机制介绍
m0_73671382的博客
12-27 610
这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争( race )，比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。就是在一个线程进行了规定操作后，就进入等待状态( wait) )，等待其他线程执行完他们的指定代码过后 再将其唤醒(notify0));在有多个线程进行等待时，如果需要，可以使用 notifyAll0来唤醒所有的等待线程。
Java 线程间的通信机制详解
swadian2008的博客
08-21 2688
目录1、volatile 关键字2、等待唤醒（等待通知）机制（1）wait() 和 notify() 等待唤醒（2）park() 和 unpark() 等待唤醒3、join() 方法——线程排队4、管道输入输出流5、ThreadLocal类和InheritableThreadLocal类线程间通信使线程成为一个整体，提高系统之间的交互性，在提高CPU利用率的同时可以对线程任务进行有效的把控与监督。volatile有两大特性，一是可见性，二是有序性，禁止指令重排序。其中可见性就是可以让线程之间进行通信。以下两
进程、线程间通信机制
zt_xcyk的专栏
07-25 915
进程、线程间通信机制1. 管道（pipe）管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程。2. 有名管道（named pipe）有名管道也是半双工的通信方式，但是它允许无亲缘关系的进程间通信。3. 信号量（semophore）信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其
MFC线程间通信
04-05
然而，当一个应用程序中有多个线程运行时，它们可能需要共享数据或协调工作，这就涉及到线程间通信（Inter-Thread Communication，简称ITC）。MFC（Microsoft Foundation Classes）库，作为Windows平台上C++开发的...
Handler实现线程间通信机制的原理
10-31
文档详细介绍了Handler实现线程间通信过程中源码的实现机制，并对其中的Looper，MessageQueue，Message对象的初始化及sendMessage（）通过sendMessageDelayed()和sendMessageAtTime()过程的操作机流程
关于Java线程间通信-回调.docx
最新发布
09-26
此外，Java提供了其他线程间通信机制，如`wait()`, `notify()`, `notifyAll()`，以及`BlockingQueue`等。这些机制通常更适用于复杂的并发场景，比如生产者消费者模型或者线程池。例如，`BlockingQueue`可以使一个...
Linux下多线程间通信
09-14
在Linux环境下，多线程间通信是实现并发执行任务并协调数据访问的关键技术。线程间的通信主要通过共享内存和同步机制来实现，因为线程天然具有共享数据结构的能力，这意味着全局变量可以在多个线程之间共享。然而，...
java多线程编程学习(线程间通信)
08-29
等待/通知机制是 Java 中的一种线程间通信机制，通过使用 wait() 和 notify() 方法，可以实现线程间的通信。wait() 方法使当前执行代码的线程进行等待，而 notify() 方法使暂停的线程继续运行。 wait() 方法 wait...
Python如何实现线程间通信
09-16
在Python编程中，线程间通信（Inter-Thread Communication，简称ITC）是并发编程中的重要概念，特别是在处理多任务并行时。当一个程序中存在多个线程，线程间需要交换信息或数据，以协同完成任务。本文将详细探讨...
java线程间通信的通俗解释及代码示例
08-28
锁机制是java中最基本的线程间通信机制，包括互斥锁、条件变量、读写锁等。互斥锁提供了以排他方式防止数据结构被并发修改的方法。读写锁允许多个线程同时读共享数据，而对写操作是互斥的。条件变量可以以原子的方式...
几种线程间的通信机制
qq_44544313的博客
08-14 1447
几种线程间的通信机制 锁机制： 1、互斥锁：提供了在某一时刻只允许一个线程独享一块临界资源。 2、读写锁：允许多个线程同时读共享数据，而对写操作互斥 3、条件变量：可以以原子的方式阻塞进程，直到某个特定条件为真为止。对测试条件是在互斥锁的保护下进行的。条件变量一般都是和互斥锁联合使用的。 信号机制： 线程间通信的主要目的是用于线程同步。 进程间通信的几种方式？ 以linux操作系统为例(windo...
线程进程间的通信，操作系统锁机制
zhehecao的博客
08-24 211
线程进程间的通信，操作系统锁机制
线程间的通信机制
G503503的博客
12-26 466
线程间的通信机制
线程通信的四种方式
热门推荐
weixin_43786099的博客
11-10 2万+
多个线程在并发执行的时候，他们在CPU中是随机切换执行的，这个时候我们想多个线程一起来完成一件任务，这个时候我们就需要线程之间的通信了，多个线程一起来完成一个任务，线程通信一般有4种方式： 通过 volatile 关键字 通过 Object类的 wait/notify 方法 通过 condition 的 await/signal 方法 通过 join 的方式 现在有一个问题，两个线程分别打印字符串，但是当线程A每输出两次的时候，线程B就输出一次，如此反复10次。 通过 volatile 关键字 通过

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值