Linux- 线程间同步

    线程是允许应用程序并发的执行多个任务的一种机制。一个进程可以有多个线程，如果每个线程执行不同的任务，通过对线程的执行顺序进行控制（调度）就可以实现任务的并发执行。当然了多进程也可以实现任务的并发处理，但是两者之间是有区别的。最大的区别就是拥有的资源不同。进程拥有自己的独立系统资源，而线程没有独立资源，只能和属于同一进程的其他线程共享进程的系统资源。单个资源在多个用户之间共享就会存在一致性的问题，因此需要通过一定的方法来对线程共享资源进行同步。

    由于一个进程内的所有的线程之间资源共享，所以多个线程可以同时对某个数据资源进行操作。所以为了保护临界资源只能被一个线程使用，因此采用线程间的同步机制。有：互斥量，条件变量，信号量，读写锁，自旋锁，屏障等机制。

1.互斥锁
互斥锁通过锁机制来实现线程间同步。在同一时刻它通常只允许一个线程执行一个关键部分的代码。
多个线程同时访问共享数据时可能会冲突，比如两个线程都要把某个全局变量增加1，这个操作在某平台需要三条指令完成：

    1.从内存读变量值到寄存器

    2.寄存器的值加1

    3.将寄存器的值写回内存

     这就可能出现结果的不唯一性("读-修改-写"的不一致)。

解决方法：
确保同一时间只有一个线程访问数据。在访问共享资源前对互斥量进行加锁，访问完成后释放互斥量（解锁）。对互斥量进行加锁之后，任何其他试图再次对互斥量加锁的线程都会被阻塞直到当前线程释放该互斥锁。这样就可以保证每次只有一个线程可以向前执行。

#include <stdio.h>  
#include <stdlib.h>  
#include <pthread.h>  
  
#define NLOOP 5000  
  
int counter;                /* incremented by threads */  
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;  
  
void *doit(void *);  
  
int main(int argc, char **argv)  
{  
    pthread_t tidA, tidB;  
  
    pthread_create(&tidA, NULL, doit, NULL);  
    pthread_create(&tidB, NULL, doit, NULL);  
  
        /* wait for both threads to terminate */  
    pthread_join(tidA, NULL);  
    pthread_join(tidB, NULL);  
  
    return 0;  
}  
  
void *doit(void *vptr)  
{  
    int     i, val;  
  
    /* 
     * Each thread fetches, prints, and increments the counter NLOOP times. 
     * The value of the counter should increase monotonically. 
     */  
  
    for (i = 0; i < NLOOP; i++) {  
        pthread_mutex_lock(&counter_mutex);  
  
        val = counter;  
        printf("%x: %d\n", (unsigned int)pthread_self(), val + 1);  
        counter = val + 1;  
  
        pthread_mutex_unlock(&counter_mutex);  
    }  
  
    return NULL;  
} 

2.条件变量

线程间的同步还有这样一种情况：
线程A需要等某个条件成立才能继续往下执行，现在这个条件不成立，线程A就阻塞等待，而线程B在执行过程中使这个条件成立了，就唤醒线程A继续执行。在pthread库中通过条件变量（Condition Variable）来阻塞等待一个条件，或者唤醒等待这个条件的线程。
使用条件变量主要包括两个动作：
一个等待使用线程资源的线程等待“条件变量被设置为真”;
另一个线程在使用完资源后“设置条件为真”,

这样就可以保证线程间同步了。这样就存在一个关键问题，就是要保证条件变量能被正确修改，条件变量要受到特殊的保护，互斥锁就实现这样的保护功能。

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>

struct msg{
    int num;
    struct msg *next;
};
struct msg *head = NULL;

pthread_mutex_t mutex;
pthread_cond_t  has_product;

void* consumer(void *arg)
{
    struct msg *g;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        while(!head)
            pthread_cond_wait(&has_product, &mutex);

        g = head;
        head = g->next;    
        pthread_mutex_unlock(&mutex);

        printf("Consume %d\n", g->num);
        free(g);
        sleep(rand() % 6); 
    }
    
    return NULL;
}


void* producer(void *arg)
{
    struct msg *g;
    while(1)
    {
        g = (struct msg*)malloc(sizeof(struct msg));
        (struct msg*)memset(g, 0x00, sizeof(struct msg));
        g->num = rand() % 1000 + 1;
        printf("Produce %d\n", g->num);
        pthread_mutex_lock(&mutex);
        g->next = head;
        head = g;
        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&has_product);
        sleep(rand() % 5); 
    }
    
    return NULL;
}



int main(void)
{
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&has_product, NULL);
    
    pthread_t pro;
    pthread_t cus;
    srand(time(NULL));
    pthread_create(&pro, NULL, producer, NULL);
    pthread_create(&cus, NULL, consumer, NULL);
    
    pthread_join(pro, NULL);
    pthread_join(cus, NULL);

    pthread_cond_destroy(&has_product);
    pthread_mutex_destroy(&mutex);
    
    return 0;
}

3.信号量
Mutex变量是非0即1的，可看作一种资源的可用数量，初始化时Mutex是1，表示有一个可用资源，加锁时获得该资源，将Mutex减到0，表示不再有可用资源，解锁时释放该资源，将Mutex重新加到1，表示又有了一个可用资源。
信号量（Semaphore）和Mutex类似，表示可用资源的数量，和Mutex不同的是这个数量可以大于1。

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <semaphore.h>

#define  NUM  5
int      queue[NUM];
sem_t    blank_num;
sem_t    product_num;

void* consumer(void *arg)
{
    int c = 0;
    while(1)
    {
        sem_wait(&product_num);
        printf("Consume %d\n", queue[c]);
        sem_post(&blank_num);
        c = (c + 1) % NUM;
        sleep(rand() % 5);
    }
    
    return NULL;
}

void* producer(void *arg)
{
    int p = 0;
    while(1)
    {
        sem_wait(&blank_num);
        queue[p] = rand() % 1000 + 1;
        printf("Product %d\n", queue[p]);
        p = (p + 1) % NUM;
        sem_post(&product_num);
        sleep(rand() % 6);
    }
    
    return NULL;
}

int main(void)
{
    pthread_t con;
    pthread_t pro;
    sem_init(&blank_num, 0, NUM);
    sem_init(&product_num, 0, 0);
    pthread_create(&pro, NULL, producer, NULL);
    pthread_create(&con, NULL, consumer, NULL);
    
    pthread_join(pro, NULL);
    pthread_join(con, NULL);
    sem_destroy(&blank_num);
    sem_destroy(&product_num);
    return 0;
}

其他线程间同步机制：
如果共享数据是只读的，那么各线程读到的数据应该总是一致的，不会出现访问冲突。只要有一个线程可以改写数据，就必须考虑线程间同步的问题。由此引出了读者写者锁（Reader-Writer Lock）的概念，Reader之间并不互斥，可以同时读共享数据，而Writer是独占的（exclusive），在Writer修改数据时其它Reader或Writer不能访问数据，可见Reader-Writer Lock比Mutex具有更好的并发性。

用挂起等待的方式解决访问冲突不见得是最好的办法，因为这样毕竟会影响系统的并发性，在某些情况下解决访问冲突的问题可以尽量避免挂起某个线程，例如Linux内核的Seqlock、RCU（read-copy-update）等机制。