多线程

线程的同步与互斥
如果每个线程使用的变量都是其他线程不会读取和修改的，那么就不存在一致性问题。同样，如果变量是只读的，多个线程同时读取该变量也不会有一致性问题。但是，当一个线程可以修改的变量，其他线程也可以读取和修改的时候，我们就需要对这些线程进行同步，确保他们再访问变量的存储内容时不会访问到无效的值。
假设两个线程读写相同变量时，线程A读取变量然后给这个变量赋予一个新的值，但写操作需要两个存储周期。当线程B在这两个写周期读取这个变量时，可能会得到不一致的值。为了避免这个问题，就需要互斥，同一时间只允许一个线程访问该变量。
互斥量
要做到三点：

1. 代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。
2. 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。
3. 如果线程不在临界区执行，那么该线程不能阻止其他线程进入
   要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。

改进售票系统：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
int ticket = 100;
pthread_mutex_t mutex;
void *route(void *arg)
{
char *id = (char*)arg;
while ( 1 ) {
pthread_mutex_lock(&mutex);
if ( ticket > 0 ) {
usleep(1000);
printf("%s sells ticket:%d\n", id, ticket);
ticket--;
pthread_mutex_unlock(&mutex);
// sched_yield(); 放弃CPU
} else {
pthread_mutex_unlock(&mutex);
break;
}
}
}
int main( void )
{
pthread_t t1, t2, t3, t4;
pthread_mutex_init(&mutex, NULL);
pthread_create(&t1, NULL, route, "thread 1");
pthread_create(&t2, NULL, route, "thread 2");
pthread_create(&t3, NULL, route, "thread 3");
pthread_create(&t4, NULL, route, "thread 4");
pthread_join(t1, NULL);
pthread_join(t2, NULL);
pthread_join(t3, NULL);
pthread_join(t4, NULL);
pthread_mutex_destroy(&mutex);
}

条件变量:

void* route_t1(void* arg)
{
    while(1)
    {

        printf("i am thread A\n");
    }
}
void* route_t2(void* arg)
{
    while(1)
    {

        printf("i am thread B\n");
        sleep(1);
    }
}
int main()
{
    pthread_t t1,t2;

    pthread_create(&t1,NULL,route_t1,(void**)"thread 1");
    pthread_create(&t2,NULL,route_t2,(void**)"thread 2");

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);



}

总结：互斥量是为了实现互斥

初始化互斥量： 
动态方式：int pthread_mutex_init(pthread_mutex_t *restrict mutex, 
const pthread_mutexattr_t *restrict attr); 
静态分配： pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 
销毁互斥量： 
int pthread_mutex_destroy(pthread_mutex_t *mutex) 
加锁： 
int pthread_mutex_lock(pthread_mutex_t *mutex); 
解锁： 
int pthread_mutex_unlock(pthread_mutex_t *mutex);

接口如下：

初始化互斥量： 
动态方式：int pthread_mutex_init(pthread_mutex_t *restrict mutex, 
const pthread_mutexattr_t *restrict attr); 
静态分配： pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 
销毁互斥量： 
int pthread_mutex_destroy(pthread_mutex_t *mutex) 
加锁： 
int pthread_mutex_lock(pthread_mutex_t *mutex); 
解锁： 
int pthread_mutex_unlock(pthread_mutex_t *mutex);

总结：互斥量是为了实现互斥
读写锁

• 读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态，要么就是不加锁状态，而且一次只有一个线程可以对其加锁。读写锁可以有三种状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只可以一个线程可以占用写模式的读写锁，但是多个线程可以同时占用读模式的读写锁。
  读写锁非常适合于对数据结构读的次数远大于写的情况。当读写锁在写模式下，他所保护的数据结构就可以被安全的修改，因为一次只有一次一个线程可以在写模式下拥有这个锁。当读写锁在读模式下，只要线程先获取了读模式下的读写锁，该锁所保护的数据几个就可以被多个获得读模式锁的线程读取。

int counter;
pthread_rwlock_t lock;
void* route_write(void* arg)
{
    int t;
    int i=*(int*)arg;
    free(arg);
    while(1)
    {
        t=counter;
        usleep(1000);
        pthread_rwlock_wrlock(&lock);
        printf("write:%d:%#x: counter=%d ++counter=%d\n",i,pthread_self(),t,++counter);
        pthread_rwlock_unlock(&lock);
        usleep(5000);
    }
}
void* route_read(void* arg)
{
    int t;
    int i=*(int *)arg;
    free(arg);
    while(1)
    {
        pthread_rwlock_rdlock(&lock);
        printf("read:%d:%#x: counter=%d\n",i,pthread_self(),counter);
        pthread_rwlock_unlock(&lock);
        usleep(900);
    }
}
int main()
{
    int i=0;
    pthread_t tid[8];
    pthread_rwlock_init(&lock,NULL);
    for(i=0;i<3;i++)
    {
        int *p=(int* )malloc(sizeof(int));
        *p=i;
        pthread_create(&tid[i],NULL,route_write,(void* )p);
    }
    for(i=0;i<5;i++)
    {
        int *p=(int* )malloc(sizeof(int));
        *p=i;
        pthread_create(&tid[i+3],NULL,route_read,(void* )p);
    }
    for(i=0;i<8;i++)
    {
        pthread_join(tid[i],NULL);
    }
    return 0;
}

自旋锁
自旋锁与互斥量类似，但它不是通过休眠使进程阻塞，而是在获取所之前一直处于自旋状态。自旋锁可以用于以下情况:锁被持有的时间短，而且线程并不希望在重新调度上花费太多成本。
当自旋锁用在非抢占式内核中是非常有用的：除了提供互斥机制以外，它们会阻塞中断，这样中断处理程序就不会让系统陷入死锁状态，因为它需要获取已被加锁的自旋锁。
屏障
屏障是用户协调多个线程并行工作的同步机制。屏障允许每个线程等待，直到所有的合作线程都到达某一点，然后从该点继续执行。我们已经看到一种屏障，pthread_join函数本身就是一种屏障，允许一个线程等待，直到另一个线程退出。但是屏障对象的概念更广，他们允许任意数量的线程等待，直到所有的线程完成处理工作，而线程不需要退出。所有线程达到屏障后可以继续工作。