Linux入门之POSIX线程原语

最新推荐文章于 2024-09-05 18:47:12 发布

学习中呢

最新推荐文章于 2024-09-05 18:47:12 发布

阅读量524

点赞数

分类专栏： linux服务器

linux服务器专栏收录该内容

11 篇文章 0 订阅

订阅专栏

POSIX

POSIX是一种标准，例如有多线程编程标准、网络编程标准等。

POSIX多线程

Linux下，一般多线程的实现由POSIX多线程编程实现。Android系统属于Linux系统，因此NDK原生支持POSIX多线程编程。

Windows平台一般用Windows自带的API。

Visual Studio平台搭建POSIX多线程环境

因为POSIX多线程是Linux的，因此如果需要在Visual Studio下开发，需要搭建可开发环境。

首先需要下载POSIX，地址为：ftp://sourceware.org/pub/pthreads-win32/pthreads-w32-2-9-1-release.zip
创建VS空项目
添加包含目录：pthreads-w32-2-9-1-release\Pre-built.2\include以及pthreads-w32-2-9-1-release\pthreads.2
添加库目录：pthreads-w32-2-9-1-release\Pre-built.2\lib\x86
添加附加依赖项：pthreadVC2.lib
把pthreads-w32-2-9-1-release\Pre-built.2\dll\x86下面的动态库文件复制到工程的正确位置。
POSIX的编译：

VS平台中直接编译运行即可。
在Linux平台中采用gcc编译（先编译生成目标文件然后链接生成可执行程序）：gcc test.c -o test -lpthread，执行：./test。
POSIX帮助文档的查看：

在Linux系统中，安装POSIX帮助文档：sudo apt-get install manpages-posix-dev
列出所有函数man -k pthread；查看某个函数：man pthread_create
创建线程与线程的结束



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

//必须引入的头文件
#include "pthread.h"

//一个相当于Java的run方法
void *start_fun(void* arg){

    //得到线程创建的参数
    char* no = (char*)arg;
    int i = 0;
    for (; i < 10; i++){
        printf("%s thread : %d \n", no, i);
        if (i == 5){
            //线程自杀，需要返回参数
            pthread_exit((void*)2);
            //线程他杀
            //pthread_cancel()
        }
    }

    //run方法执行完，线程结束，返回
    return (void*)1;
}

void main(){

    printf("main thread\n");

    pthread_t thread;
    //创建线程，指定run方法，并且可以传入参数，在run方法的arg中可以取出
    pthread_create(&thread, NULL, start_fun, "no1");

    void* r_val;
    //等待线程结束，获取线程返回参数
    pthread_join(thread, &r_val);
    printf("return value : %d", (int)r_val);

    system("pause");
}
在代码中：

通过pthread_create创建线程，需要传入一个函数指针，相当于Java线程中的run方法。然后还需要传参，参数可以在run方法中取出。
线程被创建以后，就会执行“run”方法，该方法中可以拿到线程创建的参数，可以自杀掉线程。线程的结束需要参数。
可以通过pthread_join方法等待线程结束，并且可获取线程结束的参数。
锁

我们创建两个线程：

#include <stdlib.h>
#include <stdio.h>
#include "pthread.h"
#include <Windows.h>

int i = 0;

//一个相当于Java的run方法
void *start_fun(void* arg){

    //得到线程创建的参数
    char* no = (char*)arg;
    for (; i < 10; i++){
        Sleep(10);
        printf("%s thread : %d \n", no, i);
    }
    i = 0;

    //run方法执行完，线程结束，返回
    return (void*)1;
}

void main(){

    printf("main thread\n");

    pthread_t thread1;
    pthread_t thread2;
    //创建线程，指定run方法，并且可以传入参数，在run方法的arg中可以取出
    pthread_create(&thread1, NULL, start_fun, "no1");
    pthread_create(&thread2, NULL, start_fun, "no2");

    void* r_val1;
    void* r_val2;
    //等待线程结束，获取线程返回参数
    pthread_join(thread1, &r_val1);
    pthread_join(thread2, &r_val2);
    printf("return value : %d\n", (int)r_val1);
    printf("return value : %d\n", (int)r_val2);

    system("pause");
}

打印的结果如下：

main thread
no2 thread : 0
no1 thread : 0
no2 thread : 2
no1 thread : 2
no1 thread : 4
no2 thread : 4
no1 thread : 5
return value : 2
return value : 2
请按任意键继续…

可见，两个线程是并行执行的。i变量同时被两个线程访问。但是我们现在要求线程1先执行完，然后才到线程2执行，那么两个线程i的所有情况都会被打印出来。

这时候我们需要使用互斥锁：



#include <stdlib.h>
#include <stdio.h>
#include "pthread.h"
#include <Windows.h>

int i = 0;

//互斥锁
pthread_mutex_t m;

//一个相当于Java的run方法
void *start_fun(void* arg){

    //加锁
    pthread_mutex_lock(&m);

    //得到线程创建的参数
    char* no = (char*)arg;
    for (; i < 10; i++){
        Sleep(10);
        printf("%s thread : %d \n", no, i);
    }
    i = 0;

    //解锁
    pthread_mutex_unlock(&m);

    //run方法执行完，线程结束，返回
    return (void*)1;
}

void main(){

    printf("main thread\n");

    //初始化互斥锁
    pthread_mutex_init(&m, NULL);

    pthread_t thread1;
    pthread_t thread2;
    //创建线程，指定run方法，并且可以传入参数，在run方法的arg中可以取出
    pthread_create(&thread1, NULL, start_fun, "no1");
    pthread_create(&thread2, NULL, start_fun, "no2");

    void* r_val1;
    void* r_val2;
    //等待线程结束，获取线程返回参数
    pthread_join(thread1, &r_val1);
    pthread_join(thread2, &r_val2);
    printf("return value : %d\n", (int)r_val1);
    printf("return value : %d\n", (int)r_val2);

    //销毁互斥锁
    pthread_mutex_destroy(&m);

    system("pause");
}

输出的结果如下：

main thread
no1 thread : 0
no1 thread : 1
no1 thread : 2
no1 thread : 3
no1 thread : 4
no1 thread : 5
no1 thread : 6
no1 thread : 7
no1 thread : 8
no1 thread : 9
no2 thread : 0
no2 thread : 1
no2 thread : 2
no2 thread : 3
no2 thread : 4
no2 thread : 5
no2 thread : 6
no2 thread : 7
no2 thread : 8
no2 thread : 9
return value : 1
return value : 1
请按任意键继续…

在代码中：

我们通过pthread_mutex_init初始化了一把互斥锁，最后通过pthread_mutex_destroy进行销毁。
在线程执行的时候，我们可以通过pthread_mutex_lock、pthread_mutex_unlock进行加锁和解锁。
使用互斥锁可以解决线程死锁（ABBA）的问题。
互斥锁是先让一个线程做完，然后另外一个线程做。还有一种情况就是，一个线程先执行，生产，然后另外一个线程就会去消费。

其实视频解码的绘制使用的就是生产者–消费者的模式。图片的下载显示也是基于这种模式。比如说我们生产者生成的产品，放到一个队列里面，当生产者生产出产品的时候就会发送信号通知消费者去消费，例如RTMP推流的时候，我们本地采集音视频的时候就需要一种队列，因为本地的压缩比网络上传要快。

使用这一种模式，就需要条件变量。例子：



#include <stdlib.h>
#include <stdio.h>
#include "pthread.h"
#include <Windows.h>

//模拟产品队列
int productNum = 0;

//互斥锁
pthread_mutex_t m;
//条件变量
pthread_cond_t c;

void *produce(void* arg){

    char* no = (char*)arg;

    for (;;){
        //加锁
        pthread_mutex_lock(&m);

        //生产者生产产品
        productNum++;
        printf("%s生产产品：%d\n", no, productNum);
        //通知消费者进行消费
        pthread_cond_signal(&c);

        //解锁
        pthread_mutex_unlock(&m);

        Sleep(100);
    }
    return (void*)1;
}

void *comsume(void* arg){

    char* no = (char*)arg;

    for (;;){
        pthread_mutex_lock(&m);
        //使用while是为了防止惊群效应唤醒条件变量
        while (productNum == 0){
            //1.没有产品可以消费，等待生产者生产，即等待条件变量被唤醒
            //2.释放互斥锁，使得其他消费者可以进来等待
            //3.被唤醒的时候，解除阻塞，重新申请获得互斥锁，保证只有一个消费者消费
            pthread_cond_wait(&c, &m);
        }
        productNum--;
        printf("%s消费者消费产品：%d\n", no, productNum);
        pthread_mutex_unlock(&m);
        Sleep(1000);
    }
    return (void*)1;
}

void main(){

    printf("main thread\n");

    //初始化互斥锁
    pthread_mutex_init(&m, NULL);
    //初始化条件变量
    pthread_cond_init(&c, NULL);

    pthread_t thread_producer;
    pthread_t thread_comsumer;
    //创建线程，指定run方法，并且可以传入参数，在run方法的arg中可以取出
    pthread_create(&thread_producer, NULL, produce, "producer");
    pthread_create(&thread_comsumer, NULL, comsume, "comsumer");

    //等待线程结束，获取线程返回参数
    pthread_join(thread_producer, NULL);
    pthread_join(thread_comsumer, NULL);

    //销毁互斥锁
    pthread_mutex_destroy(&m);
    //销毁条件变量
    pthread_cond_destroy(&c);
    system("pause");
}

输出的结果如下：

main thread
producer生产产品：1
comsumer消费者消费产品：0
producer生产产品：1
producer生产产品：2
producer生产产品：3
producer生产产品：4
producer生产产品：5
producer生产产品：6
producer生产产品：7
producer生产产品：8
producer生产产品：9
comsumer消费者消费产品：8
producer生产产品：9
producer生产产品：10
producer生产产品：11
producer生产产品：12
producer生产产品：13
producer生产产品：14
producer生产产品：15
producer生产产品：16
producer生产产品：17
comsumer消费者消费产品：16

这里我通过Sleep的方式控制了生产者与消费者的效率，一般来说生产的速度要比消费的速度快。

上面是只有一个生产者和一个消费者的示例代码。一般开说，生产者和消费者都会有多个。这里我们通过线程数组的方式来实现。

示例代码如下：



#include <stdlib.h>
#include <stdio.h>
#include "pthread.h"
#include <Windows.h>

#define NUM_PRODUCER 2
#define NUM_COMSUMER 2
pthread_t threads[NUM_PRODUCER + NUM_COMSUMER];

int productNum = 0;

//互斥锁
pthread_mutex_t m;
//条件变量
pthread_cond_t c;

void *produce(void* arg){

    int no = (int)arg;

    for (;;){
        //加锁
        pthread_mutex_lock(&m);

        //生产者生产产品
        productNum++;
        printf("%d生产产品：%d\n", no, productNum);
        //通知消费者进行消费
        pthread_cond_signal(&c);

        //解锁
        pthread_mutex_unlock(&m);

        Sleep(100);
    }
    return (void*)1;
}

void *comsume(void* arg){

    int no = (int)arg;

    for (;;){
        pthread_mutex_lock(&m);
        while (productNum == 0){
            //没有产品可以消费，等待生产者生产
            pthread_cond_wait(&c, &m);
        }
        productNum--;
        printf("%d消费者消费产品：%d\n", no, productNum);
        pthread_mutex_unlock(&m);
        Sleep(1000);
    }
    return (void*)1;
}

void main(){

    printf("main thread\n");

    //初始化互斥锁
    pthread_mutex_init(&m, NULL);
    //初始化条件变量
    pthread_cond_init(&c, NULL);

    int i = 0;
    //创建生产者线程
    for (i = 0; i < NUM_PRODUCER; i++){
        pthread_create(&threads[i], NULL, produce, (void*)i);
    }


    //创建消费者线程
    for (i = 0; i < NUM_COMSUMER; i++){
        pthread_create(&threads[NUM_PRODUCER + i], NULL, comsume, (void*)i);
    }

    //等待线程结束，获取线程返回参数
    for (i = 0; i < NUM_PRODUCER + NUM_COMSUMER; i++){
        pthread_join(threads[i], NULL);
    }

    //销毁互斥锁
    pthread_mutex_destroy(&m);
    //销毁条件变量
    pthread_cond_destroy(&c);
    system("pause");
}