C语言之多线程编程

1、

#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
struct Test{
    int num;
    int age;
};
struct Test t;
void *callback(void *arg){
    for (int i = 0; i < 5; ++i) {
        printf("子线程：i=%d\n",i);
    }
    printf("子线程：%ld\n",pthread_self());
    //t这个变量在进程空间中，当主线程退出后要释放这块空间，所以num和age这两个值会变成随机值
    //所以可以把t定义成全局变量
    //struct Test t;
    t.num=100;
    t.age=10;

    pthread_exit(&t);
    return NULL;
}
int main(){
    pthread_t tid;
    //pthread_create函数用于创建一个新的线程。它接受四个参数：指向线程标识符的指针、线程属性、线程运行函数的指针以及传递给线程运行函数的参数。
    pthread_create(&tid,NULL,callback,NULL);
//    for (int j = 0; j < 5; ++j) {
//        printf("主线程：j=%d\n",j);
//    }
//pthread_self函数用于获取调用线程的线程标识符。它返回一个pthread_t类型的值，表示当前线程的标识符。
   printf("主线程：%ld\n",pthread_self());

    //主线程睡3秒，等待子线程执行
    //sleep(3);

    //pthread_exit(NULL)调用他的主线程退出，但是子线程继续执行完再释放进程空间
    //传递给pthread_exit的参数是NULL，那么线程将以默认方式退出。这意味着线程的资源会被系统自动回收，包括线程的栈空间和其他相关资源。
    // pthread_exit(NULL);

    //主线程等待子线程tid，并回收子线程资源
    //如果子线程在执行，就阻塞。如果子线程执行完毕，就回收子线程资源。
    //只能阻塞等待指定的一个子线程
    //pthread_join(tid,NUll);

    //用ptr接收pthread_exit(&t)返回的空间
    void *ptr;
    pthread_join(tid,&ptr);
    struct Test *tt=(struct Test *)ptr;
    printf("num= %d, age=%d\n",(tt->num),tt->age);
    return 0;
}

2、pthread_create函数的回调函数和参数

#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
struct Test{
    int num;
    int age;
};
void *callback(void *arg){
    struct Test *t=( struct Test *)arg;
    for (int i = 0; i < 5; ++i) {
        printf("子线程：i=%d\n",i);
    }
    printf("子线程：%ld\n",pthread_self());
    t->num=100;
    t->age=10;
    return NULL;
}
int main(){
    struct Test t;
    pthread_t tid;
    //pthread_create函数用于创建一个新的线程。它接受四个参数：指向线程标识符的指针、线程属性、线程运行函数的指针以及传递给线程运行函数的参数。
    //空间t被线程改写了
    pthread_create(&tid,NULL,callback,&t);

    //pthread_self函数用于获取调用线程的线程标识符。它返回一个pthread_t类型的值，表示当前线程的标识符。
   printf("主线程：%ld\n",pthread_self());
    //阻塞主线程，等待tid子线程执行完毕
    pthread_join(tid,NULL);
    
    //没有用pthread_exit(&t);返回空间，把&t这个空间传给子线程，子线程改写了这个空间
    printf("num= %d, age=%d\n",t.num,t.age);
    return 0;
}

3、pthread_detach(tid); 

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

void *callback(void *arg){

    for (int i = 0; i < 5; ++i) {
        printf("子线程：i=%d\n",i);
    }
    printf("子线程：%ld\n",pthread_self());
    return NULL;
}
int main(){
    pthread_t tid;
    //pthread_create函数用于创建一个新的线程。它接受四个参数：指向线程标识符的指针、线程属性、线程运行函数的指针以及传递给线程运行函数的参数。
    pthread_create(&tid,NULL,callback,NULL);

    //pthread_self函数用于获取调用线程的线程标识符。它返回一个pthread_t类型的值，表示当前线程的标识符。
   printf("主线程：%ld\n",pthread_self());

   //pthread_detach函数用于将指定的线程标识符所代表的线程设置为分离状态。
   //当子线程执行完毕后会自动释放资源，不用主线程调用pthread_join(tid,NULL)来回收子线程资源，给主线程减负
   //但是当主线程执行完毕时要释放进程空间，所以要调用pthread_exit(NULL);
    pthread_detach(tid);

    //pthread_exit (NULL)调用他的主线程退出，但是子线程继续执行完再释放进程空间
    pthread_exit(NULL);
    return 0;
}

线程同步：

当几个线程同时访问一块内存空间资源，我们需要给他们指定先后顺序，不然会出现数据错误。

拿数数举例：两个线程同时对一个变量++，两个线程会抢时间片执行数数，通过从内存中拿到变量进行++操作，如++后的变量还没来得及从寄存器中更新到内存上，第二个线程开始执行数数操作，从内存是取到的值是上一个线程执行开始拿到的值，就会出现重复++操作

1、互斥锁

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

#define MAX 50
//全局变量
int number;

//pthread_mutex_t mutex; 是定义一个互斥锁
pthread_mutex_t mutex;

//线程处理函数
void *funA(void *arg){
    for (int i = 0; i < MAX; ++i) {
        //这行代码是用来对互斥锁进行加锁操作的。当一个线程执行这行代码时，
        // 它会尝试获取mutex所代表的互斥锁。如果这个互斥锁当前没有被其他线程占用，
        // 那么这个线程将成功获取锁，并继续执行后续的代码。
        // 如果这个互斥锁已经被其他线程占用，那么这个线程将被阻塞，直到获取到互斥锁为止。
        pthread_mutex_lock(&mutex);
        int cur=number;
        cur++;
        //让当前线程休眠10微秒
        usleep(10);
        number=cur;
        //%lu 是用来格式化输出一个无符号长整型数的占位符。
        printf("A: id=%lu,number= %d\n",pthread_self(),number);
        //解锁
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void *funB(void *arg){
    for (int i = 0; i < MAX; ++i) {
        //这行代码是用来对互斥锁进行加锁操作的。当一个线程执行这行代码时，
        // 它会尝试获取mutex所代表的互斥锁。如果这个互斥锁当前没有被其他线程占用，
        // 那么这个线程将成功获取锁，并继续执行后续的代码。
        // 如果这个互斥锁已经被其他线程占用，那么这个线程将被阻塞，直到获取到互斥锁为止。
        pthread_mutex_lock(&mutex);
        int cur=number;
        cur++;
        //让当前线程休眠10微秒
        usleep(10);
        number=cur;
        //%lu 是用来格式化输出一个无符号长整型数的占位符。
        printf("B: id=%lu,number= %d\n",pthread_self(),number);
        //解锁
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}
int main(){
    //这行代码是用来初始化一个互斥锁的。第一个参数是指向要初始化的互斥锁的指针，
    // 第二个参数是用来指定互斥锁的属性，通常可以传入NULL来使用默认属性。
    // 这行代码会将mutex所代表的互斥锁初始化为默认属性的状态。
    pthread_mutex_init(&mutex,NULL);

    pthread_t p1,p2;
    //创建两个子线程
    pthread_create(&p1,NULL,funA,NULL);
    pthread_create(&p2,NULL,funB,NULL);

    //阻塞，资源回收
    pthread_join(p1,NULL);
    pthread_join(p2,NULL);

    //这行代码是用来销毁一个互斥锁的。它会释放由mutex所代表的互斥锁所占用的资源，
    // 并将这个互斥锁恢复到未初始化的状态。通常在不再需要使用互斥锁时调用这个函数来释放相关资源。
    pthread_mutex_destroy(&mutex);

    return 0;
}

 2、条件变量：

是多线程程序中用来实现等待和唤醒逻辑常用的方法。

以下面代码为例，当生产者线程创建链表节点后，会调用pthread_cond_broadcast(&cond)来通知消费者线程来打印节点数据并释放节点，当消费者线程消费完后，会调用pthread_cond_wait(&cond, &mutex)阻塞消费者线程，等待新的pthread_cond_broadcast(&cond)

下面的代码我没看懂，画了下下面的一张图 

       // 节点的连接, 添加到链表的头部, 新节点就新的头结点
        pnew->next = head;
        // head指针前移
        head = pnew;

 

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

// 链表的节点
struct Node
{
    int number;
    struct Node* next;
};

// 定义条件变量, 控制消费者线程
pthread_cond_t cond;
// 互斥锁变量
pthread_mutex_t mutex;
// 指向头结点的指针
struct Node * head = NULL;

// 生产者的回调函数
void* producer(void* arg)
{
    // 一直生产
    while(1)
    {
        pthread_mutex_lock(&mutex);
        // 创建一个链表的新节点
        struct Node* pnew = (struct Node*)malloc(sizeof(struct Node));
        // 节点初始化
        pnew->number = rand() % 1000;
        // 节点的连接, 添加到链表的头部, 新节点就新的头结点
        pnew->next = head;
        // head指针前移
        head = pnew;
        printf("+++producer, number = %d, tid = %ld\n", pnew->number, pthread_self());
        pthread_mutex_unlock(&mutex);


        /* 生产了任务, 通知消费者消费
         * 这行代码是用来向所有等待在条件变量上的线程发送信号，通知它们条件已经满足。
         * 这将唤醒所有等待在cond条件变量上的线程，让它们可以继续执行。*/
        pthread_cond_broadcast(&cond);

        // 生产慢一点
        sleep(rand() % 3);
    }
    return NULL;
}

// 消费者的回调函数
void* consumer(void* arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        // 一直消费, 删除链表中的一个节点
//        if(head == NULL)   // 这样写有bug

        while(head == NULL)//生产者没有创建节点
        {
            /*这行代码是让当前线程在条件变量上等待，并且会释放对互斥锁mutex的占有。
             * 当其他线程调用pthread_cond_signal或pthread_cond_broadcast来通知条件满足时，
             * 等待在条件变量上的线程将被唤醒，并重新获取互斥锁mutex，然后继续执行。*/
            pthread_cond_wait(&cond, &mutex);
            // 当消费者线程解除阻塞之后, 会自动将这把锁锁上
            // 这时候当前这个线程又重新拥有了这把互斥锁
        }
        // 取出链表的头结点, 将其删除
        struct Node* pnode = head;
        printf("--consumer: number: %d, tid = %ld\n", pnode->number, pthread_self());
        head  = pnode->next;
        free(pnode);
        pthread_mutex_unlock(&mutex);

        sleep(rand() % 3);
    }
    return NULL;
}

int main()
{
    // 初始化条件变量
    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&mutex, NULL);

    // 创建5个生产者, 5个消费者
    pthread_t ptid[5];
    pthread_t ctid[5];
    for(int i=0; i<5; ++i)
    {
        pthread_create(&ptid[i], NULL, producer, NULL);
    }

    for(int i=0; i<5; ++i)
    {
        pthread_create(&ctid[i], NULL, consumer, NULL);
    }

    // 释放资源
    for(int i=0; i<5; ++i)
    {
        // 阻塞等待子线程退出
        pthread_join(ptid[i], NULL);
    }

    for(int i=0; i<5; ++i)
    {
        pthread_join(ctid[i], NULL);
    }

    // 销毁条件变量
    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);

    return 0;
}