[NDK] -POSIX线程学习三

线程同步之互斥锁

---

//初始化互斥锁
int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* attr);

//锁定互斥锁
int pthread_mutex_lock(pthread_mutex_t* mutex);

//解锁互斥锁
int pthread_mutex_unlock(pthread_mutex_t* mutex);

//销毁互斥锁
int pthread_mutex_destroy(pthread_mutex_t* mutex);

• native-thread.cpp

#include <jni.h>
#include <string>
#include <cstdio>
#include <pthread.h>
#include <unistd.h>

//线程worker参数
struct NativeWorkerArgs {
    jint id;
    jint iteration;
};

//能被缓存的java方法ID
static jmethodID gOnNativeMessage = nullptr;

// Java VM 接口指针
static JavaVM *gVm = nullptr;

// thiz对象的全局引用
static jobject gObj = nullptr;

//互斥锁实例
static pthread_mutex_t mutex;

/**
 * 当共享库开始加载时，虚拟机自动调用这个函数，可以从这里获取JAVA VM的指针
 * @param vm
 * @param reserved
 * @return
 */
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    //获取JAVA VM 全局指针
    gVm = vm;
    return JNI_VERSION_1_6;
}

static void *nativeWorkerThread(void *args) {
    JNIEnv *env = nullptr;

    if (0 != pthread_mutex_lock(&mutex)) {
        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
        env->ThrowNew(exceptionClazz, "Unable to lock mutex");
        goto exit;
    }

    if (0 == gVm->AttachCurrentThread(&env, nullptr)) {
        NativeWorkerArgs *nativeWorkerArgs = (NativeWorkerArgs *) args;
        //Java_com_zhuhongxi_nativcethreaddemo1_MainActivity_nativeWorker(env, gObj, nativeWorkerArgs->id, nativeWorkerArgs->iteration);
        for (int i = 0; i < nativeWorkerArgs->iteration; ++i) {
            char message[26];
            sprintf(message, "Worker %d: Iteration %d", nativeWorkerArgs->id, i);
            jstring messageString = env->NewStringUTF(message);
            env->CallVoidMethod(gObj, gOnNativeMessage, messageString);
            if (nullptr != env->ExceptionOccurred())
                break;
            sleep(1);
        }
        delete nativeWorkerArgs;
        gVm->DetachCurrentThread();
    }

    if (0 != pthread_mutex_unlock(&mutex))
    {
        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
        env->ThrowNew(exceptionClazz, "Unable to unlock mutex");
    }

    exit:
    return (void *) 1;
}

extern "C"
JNIEXPORT void JNICALL
Java_com_zhuhongxi_nativcethreaddemo1_MainActivity_nativeInit(JNIEnv *env, jobject thiz) {

    //初始化互斥锁
    if (0 != pthread_mutex_init(&mutex, nullptr)) {
        //初始化失败则抛出一个异常
        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
        env->ThrowNew(exceptionClazz, "Unable to initialize mutex");
        goto exit;
    }

    if (nullptr == gOnNativeMessage) {
        //从对象中获取类
        jclass clazz = env->GetObjectClass(thiz);
        //获取java中回调方法的method ID
        gOnNativeMessage = env->GetMethodID(clazz, "onNativeMessage", "(Ljava/lang/String;)V");
        //如果方法没找到就抛出一个异常
        if (nullptr == gOnNativeMessage) {
            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "Unable to find method");
        }
    }

    if (nullptr == gObj) {
        //创建一个全局的引用指向this(这个this是java的上下文，在这里也就是MainActivity)
        gObj = env->NewGlobalRef(thiz);
        if (nullptr == gObj) {
            goto exit;
        }
    }

    exit:
    return;
}

extern "C"
JNIEXPORT void JNICALL
Java_com_zhuhongxi_nativcethreaddemo1_MainActivity_nativeFree(JNIEnv *env, jobject thiz) {
    if (nullptr != gObj) {
        //使用结束后记得释放全局的引用，回收资源
        env->DeleteGlobalRef(gObj);
        gObj = nullptr;

        //销毁互斥锁
        if (0 != pthread_mutex_destroy(&mutex)) {
            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "Unable to destroy mutex");
        }
    }
}


extern "C"
JNIEXPORT void JNICALL
Java_com_zhuhongxi_nativcethreaddemo1_MainActivity_posixThreads(JNIEnv *env, jobject thiz,
                                                                jint threads, jint iterations) {

    //线程句柄
    pthread_t *handles = new pthread_t[threads];

    //为每一个worker创建一个posix线程去执行
    for (jint i = 0; i < threads; i++) {
        //组装每一个worker参数
        NativeWorkerArgs *nativeWorkerArgs = new NativeWorkerArgs();
        nativeWorkerArgs->id = i;
        nativeWorkerArgs->iteration = iterations;
        //创建pthread
        pthread_t thread;
        int result = pthread_create(&handles[i], nullptr, nativeWorkerThread,
                                    (void *) nativeWorkerArgs);
        //如果创建失败就抛出一个java异常
        if (0 != result) {
            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "Unable to create native thread");
            goto exit;
        }
    }

    /*for (int i = 0; i < threads; ++i) {
        void* result = nullptr;
        if (0 != pthread_join(handles[i], &result))
        {
            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "Unable to join thread");
        }
        else
        {
            char message[26];
            sprintf(message, "Worker %d: Iteration %d", i, result);
            //新建一个字符串
            jstring messageString = env->NewStringUTF(message);
            //调用java中的回调方法
            env->CallVoidMethod(gObj, gOnNativeMessage, messageString);
            if (nullptr != env->ExceptionOccurred())
            {
                goto exit;
            }
        }
    }*/
    exit:
    return;
}