同步

同 步

 

   在进行多线程和多进程编程的时候，总会遇到多个进程或多个线程对同一块数据的访问。这是我们就需要使用某种同步的手段来保证数据的正确访问。

 

1 互斥锁和条件变量

 使用范围：同一进程中的不同线程间；

1.1 互斥锁    

*基本概念
    互斥锁是指相互排斥，是最基本的同步形式。它可以用来保护临界区，以保证任何时候都只有多个线程中的一个线程在期间运行。

    注意：如果在多个进程间，而且每个进程都有独立的互斥锁变量的内存空间，这样每个进程都可以调用pthread_mutex_lock那么这样的互斥锁将失去意义。例如：

下面的代码是usp上的14-1的一段   

...

pthread_mutex_t mutex;

...

for (i = 1; i < n; i++)
      if (childpid = fork())            //创建进程链
         break;
   snprintf(buffer, BUFSIZE,
       "i:%d  process ID:%ld  parent ID:%ld  child ID:%ld/n",
       i, (long)getpid(), (long)getppid(), (long)childpid);
 
    c = buffer;
   /********** start of critical section *****************/

   //到这里每个子进程都拥有mutex的内存空间和变量值，所以这里无法完成互斥

   pthread_mutex_lock(&mutex);
   while (*c != '/0') {
      fputc(*c, stderr);
      c++;
      for (i = 0; i < delay; i++)
         dummy++;
   }

   pthread_mutex_unlock(&mutex);

 /************** end of critical section **************/
   if (r_wait(NULL) == -1)
      return 1;
   ...

*锁互斥的初始化
    .静态初始化
        static    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    .动态初始化           
        static pthread_mutex_t lock;
        pthread_mutex_init(&lock, NULL);

*使用形式
    static    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_lock(&lock);
    ... /* 需要保护的操作 */
    pthread_mutex_unlock(&lock);

*加锁函数
    //如果出错则阻塞
    pthread_mutex_lock(pthread_mutex_t *lock)
    //如果出错立即返回，errno=EBUSY
    pthread_mutex_trylock(pthread_mutex_t *lock)

1.2 条件变量
    如果没有条件变量线程可能一直阻塞或轮训的方式来进行相互的操作，也就是说线程根本就不知道是否可以进行下面的操作而，只有进行轮训去查询看是否满足条件。  
    条件变量和互斥锁结合才不至于线程进行忙等。       

*相关函数1   
    #include <pthread.h>
    int pthread_cond_wait(pthread_cond_t *cptr, pthread_mutex_t *mpthr);
注意：
    .在使用该函数前必须要用互斥锁锁住线程，然后再调用该函数。
    .在没有返回前该函数会自动释放mpthr锁。
    .该函数会阻塞在条件变量cptr上，
    .返回时，该函数又自动加上锁。
    .一般的使用结构
    pthread_mutex_lock(&l);
    while (condition is true)
        pthread_cond_wait(&cond, &l);
    pthread_mutex_unlock(&l);


*相关函数2   
    #include <pthread.h>
    int pthread_cond_broadcast(pthread_cond_t *cond);
    in pthread_cond_signal(pthread_cond_t *cptr);

 

注意：
       .第一个函数解除了所有阻塞在cond上的条件变量上的线程的阻塞。
    .第二个函数解除了至少一个阻塞在cond指向的条件变量上的线程。
    .调用这两个函数线程可以没有被加锁，但如果没有阻塞在条件变量的线程，那么它们不起任何作用。
    .如果有多个线程阻塞在条件变量cond上，那么那个先运行决定系统的调度。

 

 

实例：

/* * 生产者和消费者在环形缓冲区中的实现和运用 */#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>#include <fcntl.h>#include <signal.h>#include <errno.h>#include <pthread.h>#include <sys/types.h> #include <sys/stat.h>#include <time.h>#define MAXLEN 10struct manqueue{int arrlen; /* array total length */ int count; /* current queue quantity */int putpos;int getpos;};struct _node{char name[16];int ID; };typedef struct _node Node; /* A Node structure. */static Node st[MAXLEN]; /* Buffer length */static struct manqueue mq;static pthread_mutex_t mutex; static pthread_cond_t items;static pthread_cond_t slots;static pthread_attr_t attr;int reader(Node *st);int writer(Node *pnode);static void *workproc(void *arg);int main(void){/*pthread_t rtid, wrtid;*/int ti,tj;Node tst[10];Node rst;pthread_t rtid,wtid;mq.count = 0;mq.putpos = 0;mq.getpos = 0;mq.arrlen = MAXLEN; pthread_attr_init(&attr);pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);pthread_mutex_init(&mutex, NULL);pthread_cond_init(&items, NULL);pthread_cond_init(&slots, NULL);for (tj=0; tj<3; tj++) {pthread_create(&rtid, NULL, (void *)reader, &rst);}for (ti=0; ti<10; ti++) {strcpy(tst[ti].name, "hov");tst[ti].ID = ti;pthread_create(&wtid, NULL, (void *)writer, tst+ti);}pause();exit(0);}/* * Read queue buffer data. */int reader(Node *rst){while (1) {pthread_mutex_lock(&mutex);while(mq.count <= 0) /* queue is empty */pthread_cond_wait(&items, &mutex); memmove(rst, &st[mq.getpos], sizeof(Node));printf("read->[%d]=[%s-%d]/n", mq.getpos, rst->name, rst->ID);mq.getpos++;if(mq.getpos == mq.arrlen) /* roll to header */mq.getpos = 0;mq.count--;//pthread_cond_signal(&slots);//说明有空闲的位置了。pthread_mutex_unlock(&mutex); }return 0;}/* * Write pnode value to the buffer queue */int writer(Node *pnode){while (1) {sleep(1);//这时为了让我们看清楚结果而加的pthread_mutex_lock(&mutex);/*`//如果这里注释掉的话，就可能使得现在写的数据把while(mq.count >= mq.arrlen) //已经写的数据覆盖掉。所以最好是加上它。{//如果不加的话，说明本来就有可能丢失数据pthread_cond_wait(&slots, &mutex);}*///向空闲缓冲区中放数据strcpy(st[mq.putpos].name, pnode->name);st[mq.putpos].ID = pnode->ID;fprintf(stderr, "write->[%d]=[%s-%d]/n", mq.putpos,st[mq.putpos].name, st[mq.putpos].ID);/* roll to header */mq.putpos++;if(mq.putpos == mq.arrlen)mq.putpos = 0;mq.count++;pthread_cond_signal(&items);pthread_mutex_unlock(&mutex);}return 0;}

 

 

小结： 互斥锁和条件变量一般用于同一进程的不同线程间的同步， 用法比较简单，应用比较广，比较重要的就是环形缓冲区模型，以及生产者消费者模型。

 

2  posix信号灯

   信号灯是一种提供不同进程间或一个给定进程的不同线程间同步的原语。其中有三种信号灯比较常用：

       .posix有名信号灯

             posix有名信号灯使用posix IPC名字，可用于多个进程和线程间的同步。

       .posix内存信号灯

             posix内存信号灯存放在内存区中，可用于多个线程间的同步；如果多个进程间有共享内存，而信号灯变量在共享

       内存区内，那么posix内存信号灯也可以用于多个进程间的同步。

       .system v 信号灯：在内核中维护，可用于进程或线程的同步。

 

*二值信号灯和计数信号灯

    信号灯可以分为二值信号灯和计数信号灯。二值信号灯只有两个值0或1，而计数信号灯的值可以大于1。

 

*对信号的操作

    .创建信号一个信号灯。通常还需要调用者指定初始值，对于二值信号灯来说，它通常是1。对于计数信号灯要具体情况具体设定。

    .等待一个信号灯（P操作）。该操作测试信号灯的值，如果其值小于或等于0，那就阻塞，一旦其值大于0就将它减1。而且该操作必须是一个原子操作。

    .挂出一个信号灯（V操作）。该操作将信号灯的值加1，如果有一些进程等待该信号灯的值变为大于0，其中一个进程现在就可能被唤醒。该操作也必须是一个原子操作，所做的事情有：信号灯＋1；解锁；发信号。

 

*信号灯的使用模型

    .互斥锁模式

          sem = 1;

          sem_wait(&sem);

          临界区

          sem_post(&sem);

 

    .生产者，消费者模型

 

          生产者                                                                  消费者

          get = 0;

          put = 1;

 

          for ( ; ; ) {                                                      for ( ; ; ) {

             sem_wait(&put);                                             sem_wait(&get);

             把数据放入缓冲区中                                             处理缓冲区中的数据

             sem_post(&get);                                             sem_post(&put);

          }                                                                    }

 

    .注意 ：

        下面这种模型是错误的：

        sem_t mysem;

        sem_init(&mysem, 1, 0);   //the 2nd arg of 1 : shared between processes

        if (fork() == 0) {              //child

           ...

           sem_post(&mysem);

        }                                  

        sem_wait(&mysem);       //parent

 

        想想为什么？

          

 

*信号灯和互斥锁的差异：

    .互斥锁必须是由给他上锁的线程解锁，信号灯的挂出不必由执行过它的等待操作的同一线程执行。

    .在使用互斥锁时，如果线程发送了一个信号，但是没有线程在等待这个信号的到来，那么这个信号就会丢失。但信号量将会记下这次的信号量。不会丢失。

    .

 

*有名信号量和基于内存的信号量的函数调用

 

                有名信号灯                               基于内存的信号灯

              sem_open()                                sem_init()

                      /                                              /

                                                  

                                    sem_wait()

                                    sem_trywait()

                                    sem_post()

                                    sem_getvalue()

                          /                                      /

           sem_close()                               sem_destory()

           sem_unlink()

 

 

2.1 有名信号灯