1. 各个线程读写同一个共享变量, 此时需要使用锁. 各个线程就像是汇聚到一个点的各种线一样.
2. 线程需要互相协作, 在某些点上完成之后再进入到下一个阶段. 有点像本来各个线程是平行线, 然后在会在一个固定的地方交汇, 然后再到下一阶段, 再在固定的地方交汇
3. 线程之间不交汇, 而是通过共享缓冲区操作, 就像两个车间之间通过一条传送带传送数据, 两个车间中各种一批线程在运行

1. 违反原子性缺陷
2. 违反顺序缺陷
3. 死锁
4. 操作系统提供的事件API
5. select与异步IO合用

违反原子性缺陷

违反顺序缺陷

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

sem_t sem;
sem_t sem1;

typedef struct my {
    int a;
    int *b;
} my_struct;

void *init(void *arg) {
    printf("This is child \n");

    my_struct *new_arg = (my_struct *) arg;

    new_arg->a = 0;
    new_arg->b = &new_arg->a;

    printf("init completed\n");

    sem_post(&sem);

    return NULL;
}

void *child2(void *arg) {
    printf("This is child2 \n");

    my_struct *new_arg = (my_struct *) arg;

    if (new_arg->b == NULL) {
        printf("pointer is null , forbidden to read");
    } else {
        printf("b is %d\n", *(new_arg->b));

    }

    printf("child2 ends\n");

    sem_post(&sem1);

    return NULL;
}

int main(void) {

    sem_init(&sem, 0, 0);
    sem_init(&sem1, 0, 0);
    my_struct * cc = malloc(sizeof(struct my));
    printf("child thread begins\n");
    pthread_t c;
    pthread_t c2;


    pthread_create(&c, NULL, child2, cc);
    pthread_create(&c2, NULL, init, cc);

    sem_wait(&sem);
    sem_wait(&sem1);

    printf("Child threads ends\n");

    return 0;
}

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

sem_t sem;
sem_t sem1;

typedef struct my {
    int a;
    int *b;
} my_struct;


void *init(void *arg) {
    printf("This is init \n");

    my_struct *new_arg = (my_struct *) arg;

    new_arg->a = 0;
    new_arg->b = &new_arg->a;

    printf("init completed\n");

    //init线程执行结束之后, 对sem信号量执行V操作
    sem_post(&sem);

    return NULL;
}


void *child2(void *arg) {

    //child2等待init1结束再开始进行动作
    sem_wait(&sem);

    printf("This is child2 \n");

    my_struct *new_arg = (my_struct *) arg;

    printf("b is %d\n", *(new_arg->b));

    printf("child2 ends\n");

    //init线程执行结束之后, 对sem1信号量执行V操作
    sem_post(sem1)
    
    return NULL;
}

int main(void) {

    sem_init(&sem, 0, 0);
    sem_init(&sem1, 0, 0);

    my_struct * cc = malloc(sizeof(struct my));


    printf("child thread begins\n");

    pthread_t c;
    pthread_t c2;


    pthread_create(&c, NULL, child2, cc);
    pthread_create(&c2, NULL, init, cc);

    //主线程等待sem1信号量
    sem_wait(&sem1);

    printf("Child threads ends\n");

    return 0;
}

死锁

1. 互斥: 线程对于需要的资源进行互斥访问
2. 持有并等待: 线程持有一个互斥资源, 同时等待获取其他互斥资源
3. 资源被抢占后除非主动放弃, 否则无法再被抢占
4. 循环等待: 线程之间存在一个环路, 环路上的每个线程都持有其他线程等待的资源.

解除死锁 - 循环等待

解除死锁 - 持有并等待

解除死锁 - 非抢占

while true:
    lock(&L1);
    if (trylock(L2) == -1:
        unlock(L1);
    else:
        do_something()
        unlock(L2)
        unlock(L1)

解除死锁 - 互斥

int compare_and_swap(int *address, int expected, int new){
    if (*address == expected){
        *address = new;
        return 1;
    }
    return 0;
}

void AtomicIncrement(int *value, int amount){
    do {
        int old = *value
    } while(compare_and_swap(value, old, old+amount) == 0)
}

解除死锁 - 调度

解除死锁 - 检查和恢复

操作系统提供的事件API

while(1){
    // 获取所有的事件
    events = getEvents();

    for event in events:
        processEvent(event)

}

int select(
    int nfds, 一个数量, 检查每个集合中的描述符的数量
    fd_set *readfds  准备好读取的描述符集合
    fd_set *writefds 准备好写入的描述符集合
    fd_set *errorfds 有异常待处理的描述符集合
    struct timeval *timeout
    )

select与异步IO合用

1. 发起IO的接口: int aio_read(struct aiocb *target), 这个方法接收一个特殊的结构作为参数, 通过这个结构指定要读取的内容, 大小和存放的位置.
2. 检查IO是否完成的接口: int aio_error(const struct aiocb *target), 这个方法的名称有点奇怪, 用于检查这个特殊的结构是否读取完成, 如果完成了,就返回0, 如果还没有, 就返回非零.
3. 这个结构如下:

       struct aiocb {
           int aio_fildes;  //这个是文件描述符
           off_t aio_offeset; //这个是文件的偏移量, 也就是起始点
           volatile void *aio_buf; //要读取到的缓冲区位置
           size_t aio_nbytes; //要读取的长度
       }