欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  移动技术

Android NDK pthreads详细使用

程序员文章站 2022-06-26 08:58:10
这个pthread.h文件可以在NDK环境里创建子线程,并对线程能够做出互斥所、等待、销毁等控制。写这个博客的原因是我要写如何使用FFmpeg播放视频,因为同时需要播放音频和视频所以需要开启线程,并设置生产者和消费者的关系。好了直接上整体 1.开启和销毁线程 pthread_create函数能够创建 ......

这个pthread.h文件可以在NDK环境里创建子线程,并对线程能够做出互斥所、等待、销毁等控制。

写这个博客的原因是我要写如何使用FFmpeg播放视频,因为同时需要播放音频和视频所以需要开启线程,并设置生产者和消费者的关系。

好了直接上整体

1.开启和销毁线程


pthread_create函数能够创建线程,第一个参数是线程的引用,第二个是线程的属性,一般为NULL,第三个为线程运行的函数,第四个是给线程运行函数的参数

pthread_create又是开启线程,只要运行了这个函数线程就会运行起来,也就是运行第三个参数所代表的函数

    pthread_t pthreads;
    pthread_create(&pthreads, NULL, threadFunc, (void *) "zzw");

等待线程完成和返回参数,这个如果开启线程只有一个可以不写,但是如果有多个线程这个就必须要写,不写的话只会运行第一个线程

    int retvalue;
    pthread_join(pthreads,(void**)&retvalue);
    if(retvalue!=0){
        __android_log_print(ANDROID_LOG_ERROR,"hello","thread error occurred");
    }

 

我们再来看看线程运行函数,这个他可以获取参数,并且能能够提前结束线程

void * threadFunc(void *arg){

    char* str=(char*)arg;

    for(int i=0;i<3;i++){
        __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d arg = %s",i,str);
        //线程自杀,需要返回参数
        //pthread_exit((void*)2);
        //线程他杀
        //pthread_cancel()
    }
    return (void *) 0;

}

 

完整例子代码

#include <jni.h>
#include <string>
#include <android/log.h>
#define LOGE(FORMAT,...) __android_log_print(ANDROID_LOG_ERROR,"LC XXX",FORMAT,##__VA_ARGS__);

extern "C"
JNIEXPORT jstring
JNICALL
Java_com_example_zth_ndkthread_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}


void * threadFunc(void *arg){

    char* str=(char*)arg;

    for(int i=0;i<3;i++){
        __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d arg = %s",i,str);
        //线程自杀,需要返回参数
        //pthread_exit((void*)2);
        //线程他杀
        //pthread_cancel()
    }
    return (void *) 0;

}

extern "C"
JNIEXPORT void JNICALL
Java_com_example_zth_ndkthread_MainActivity_startNativeThread(JNIEnv* env, jobject thiz,jint count) {


    pthread_t pthreads;
    pthread_create(&pthreads, NULL, threadFunc, (void *) "zzw");


    int retvalue;
    pthread_join(pthreads,(void**)&retvalue);
    if(retvalue!=0){
        __android_log_print(ANDROID_LOG_ERROR,"hello","thread error occurred");
    }


}

 

2.互斥锁


互斥锁指的是它能够锁住一段代码,使得这段代码在解锁之前不能再被执行一次,

初始化

    pthread_mutex_t pthread_mutex;
    if(pthread_mutex_init(&pthread_mutex,NULL)!=0)
        return;

 

开启线程时把互斥锁传给线程运行函数

    for(int i=0;i<count;i++){
        pthread_create(&pthreads[i],NULL,threadFunc,&pthread_mutex);
    }

 

我们再来看看线程运行函数
取出互斥锁并上锁

    pthread_mutex_t* pthread_mutex=(pthread_mutex_t*)arg;
    pthread_mutex_lock(pthread_mutex);

 

然后一段代码

    for(int i=0;i<3;i++){
        __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",i);
    }
    __android_log_print(ANDROID_LOG_VERBOSE,"hello","————————————");

 

解锁

pthread_mutex_unlock(pthread_mutex);

 

最后销毁互斥锁

    pthread_mutex_destroy(&pthread_mutex);

 

运行效果如下

03-02 14:25:58.346 10022-10077/com.example.zth.ndkthread V/hello: i = 0
03-02 14:25:58.346 10022-10077/com.example.zth.ndkthread V/hello: i = 1
03-02 14:25:58.346 10022-10077/com.example.zth.ndkthread V/hello: i = 2
03-02 14:25:58.346 10022-10077/com.example.zth.ndkthread V/hello: ------------------------
03-02 14:25:58.346 10022-10078/com.example.zth.ndkthread V/hello: i = 0
03-02 14:25:58.346 10022-10078/com.example.zth.ndkthread V/hello: i = 1
03-02 14:25:58.346 10022-10078/com.example.zth.ndkthread V/hello: i = 2
03-02 14:25:58.346 10022-10078/com.example.zth.ndkthread V/hello: ------------------------
03-02 14:25:58.347 10022-10079/com.example.zth.ndkthread V/hello: i = 0
03-02 14:25:58.347 10022-10079/com.example.zth.ndkthread V/hello: i = 1
03-02 14:25:58.347 10022-10079/com.example.zth.ndkthread V/hello: i = 2
03-02 14:25:58.347 10022-10079/com.example.zth.ndkthread V/hello: ————————————

如果我们没有加锁呢

    pthread_mutex_t* pthread_mutex=(pthread_mutex_t*)arg;
   // pthread_mutex_lock(pthread_mutex);
    for(int i=0;i<3;i++){
        __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",i);
    }
    __android_log_print(ANDROID_LOG_VERBOSE,"hello","------------------------");
   // pthread_mutex_unlock(pthread_mutex);

 

结果如下

03-02 14:36:50.035 13815-13993/com.example.zth.ndkthread V/hello: i = 0
03-02 14:36:50.035 13815-13993/com.example.zth.ndkthread V/hello: i = 1
03-02 14:36:50.035 13815-13993/com.example.zth.ndkthread V/hello: i = 2
03-02 14:36:50.035 13815-13993/com.example.zth.ndkthread V/hello: ------------------------
03-02 14:36:50.035 13815-13994/com.example.zth.ndkthread V/hello: i = 0
03-02 14:36:50.035 13815-13994/com.example.zth.ndkthread V/hello: i = 1
03-02 14:36:50.035 13815-13994/com.example.zth.ndkthread V/hello: i = 2
03-02 14:36:50.035 13815-13995/com.example.zth.ndkthread V/hello: i = 0
03-02 14:36:50.035 13815-13994/com.example.zth.ndkthread V/hello: ------------------------
03-02 14:36:50.035 13815-13995/com.example.zth.ndkthread V/hello: i = 1
03-02 14:36:50.035 13815-13995/com.example.zth.ndkthread V/hello: i = 2
03-02 14:36:50.035 13815-13995/com.example.zth.ndkthread V/hello: ------------------------

所以互斥锁是先让一个线程做完,然后另外一个线程做。

例子代码:

#include <jni.h>
#include <string>
#include <android/log.h>
#include "pthread.h"
#define LOGE(FORMAT,...) __android_log_print(ANDROID_LOG_ERROR,"LC XXX",FORMAT,##__VA_ARGS__);



extern "C"
JNIEXPORT jstring
JNICALL
Java_com_example_zth_ndkthread_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}


void * threadFunc(void *arg){

    pthread_mutex_t* pthread_mutex=(pthread_mutex_t*)arg;
    pthread_mutex_lock(pthread_mutex);
    for(int i=0;i<3;i++){
        __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",i);
    }
    __android_log_print(ANDROID_LOG_VERBOSE,"hello","------------------------");
    pthread_mutex_unlock(pthread_mutex);
    return (void *) 0;
}

extern "C"
JNIEXPORT void JNICALL
Java_com_example_zth_ndkthread_MainActivity_startNativeThread(JNIEnv* env, jobject thiz,jint count) {

    pthread_mutex_t pthread_mutex;
    if(pthread_mutex_init(&pthread_mutex,NULL)!=0)
        return;

    pthread_t pthreads[count];
    for(int i=0;i<count;i++){
        pthread_create(&pthreads[i],NULL,threadFunc,&pthread_mutex);
    }

    for(int i=0;i<count;i++){
        int retvalue=0;
        pthread_join(pthreads[i],(void**)&retvalue);
        if(retvalue!=0){
            __android_log_print(ANDROID_LOG_ERROR,"hello","thread error occurred");
        }
    }

    pthread_mutex_destroy(&pthread_mutex);

}

 

3.条件变量


视频解码的绘制使用的就是生产者—消费者的模式。比如说我们生产者生成的产品,放到一个队列里面,当生产者生产出产品的时候就会发送信号通知消费者去消费

这个条件变量能够唤醒线程运行

初始化

pthread_cond_init(&c,NULL);

 

开启生成者线程和消费者线程

    pthread_create(&thread_producer, NULL, produce, (void *) "producer");
    pthread_create(&thread_comsumer, NULL, comsume, (void *) "comsumer");

 

循环生产产品,然后提醒消费者

    for(;;){
        pthread_mutex_lock(&m);
        productNum++;
        __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",productNum);
        pthread_cond_signal(&c);
        pthread_mutex_unlock(&m);

    }

 

消费者线程如果发现没有产品就等待条件变量提醒,,如果有产品就消费掉

        pthread_mutex_lock(&m);
        while(productNum == 0){
            pthread_cond_wait(&c,&m);

        }
        productNum--;
        __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",productNum);
        pthread_mutex_unlock(&m);

 

注意生成者与消费者线程运行的全过程都在互斥锁下,都是按顺序一一执行的,这样对于全局变量productNum的计算就不会错误,并且通过一个线程执行pthread_cond_signal来触发另一个线程执行

例子代码

#include <jni.h>
#include <string>
#include <android/log.h>
#include "pthread.h"
#define LOGE(FORMAT,...) __android_log_print(ANDROID_LOG_ERROR,"LC XXX",FORMAT,##__VA_ARGS__);



extern "C"
JNIEXPORT jstring
JNICALL
Java_com_example_zth_ndkthread_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}

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++;
        __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",productNum);
        pthread_cond_signal(&c);
        pthread_mutex_unlock(&m);

    }
}

void *comsume(void* arg){
    char* no = (char*)arg;
    for(;;){
        pthread_mutex_lock(&m);
        while(productNum == 0){
            pthread_cond_wait(&c,&m);

        }
        productNum--;
        __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",productNum);
        pthread_mutex_unlock(&m);



    }
}


extern "C"
JNIEXPORT void JNICALL
Java_com_example_zth_ndkthread_MainActivity_startNativeThread(JNIEnv* env, jobject thiz,jint count) {

    pthread_mutex_init(&m,NULL);
    pthread_cond_init(&c,NULL);

    pthread_t thread_producer;
    pthread_t thread_comsumer;

    pthread_create(&thread_producer, NULL, produce, (void *) "producer");
    pthread_create(&thread_comsumer, NULL, comsume, (void *) "comsumer");

    pthread_join(thread_producer,NULL);
    pthread_join(thread_comsumer,NULL);

    pthread_mutex_destroy(&m);
    pthread_cond_destroy(&c);


}

 

参考文章

https://www.jianshu.com/p/453d12c16885

http://blog.csdn.net/lxmhuendan/article/details/11967593