这个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