POSIX 线程

POSIX 线程也被简称为 Pthreads，是一个线程的 POSIX 标准。

#include <pthread.h>

int pthread_create(
  pthread_t*  thread,
  pthread_attr_t  const*  attr,
  void*  (*start_routine)(void*),
  void*  arg
);

参数：

1、指向 thread_t 类型变量的指针，函数用该指针返回新线程的句柄。

2、指向 pthread_attr_t 结构的指针形式存在的新线程属性，可以通过该属性指定新线程的栈基址、栈大小、守护大小、调度策略和调度优先级等。

3、指向线程启动程序的函数指针，启动程序函数签名格式如下：

void*  start_routine(void* args)

启动程序将线程参数看成 void 指针，返回 void 指针类型结果。

当线程以空指针的形式执行时，参数都需要被传递给启动程序，如果不需要传递参数，它可以为空指针。成功时，pthread_create 函数返回 0，否则返回一个错误代码。

示例代码

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

// POSIX 线程
#include <pthread.h>

#include "com_apress_threads_MainActivity.h"

// Native worker thread arguments
// 原生 worker 线程参数
struct NativeWorkerArgs
{
    jint id;
    jint iterations;
};

// Method ID can be cached 方法 ID 能被缓存
static jmethodID gOnNativeMessage = NULL;

// Java VM interface pointer Java 虚拟机接口指针
static JavaVM* gVm = NULL;

// Global reference to object 对象的全局引用
static jobject gObj = NULL;

// Mutex instance 互斥实例
static pthread_mutex_t mutex;

// 在原生代码中获取 Java 虚拟机接口指针
// 当共享库开始加载时虚拟机自动调用 JNI_OnLoad 函数
jint JNI_OnLoad (JavaVM* vm, void* reserved)
{
    // Cache the JavaVM interface pointer 缓存 Java 虚拟机接口指针
    gVm = vm;

    return JNI_VERSION_1_4;
}

void Java_com_apress_threads_MainActivity_nativeInit (
        JNIEnv* env,
        jobject obj)
{
    // Initialize mutex 初始化互斥
    if (0 != pthread_mutex_init(&mutex, NULL))
    {
        // Get the exception class 获取异常类
        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");

        // Throw exception 抛出异常
        env->ThrowNew(exceptionClazz, "Unable to initialize mutex");
        goto exit;
    }

    // If object global reference is not set 如果对象的全局引用未设置
    if (NULL == gObj)
    {
        // Create a new global reference for the object 为对象创建一个新的全局引用
        gObj = env->NewGlobalRef(obj);

        if (NULL == gObj)
        {
            goto exit;
        }
    }

    // If method ID is not cached 如果方法 ID 没被缓存
    if (NULL == gOnNativeMessage)
    {
        // Get the class from the object 从对象中获取类
        jclass clazz = env->GetObjectClass(obj);

        // Get the method id for the callback 为回调获取方法 ID
        gOnNativeMessage = env->GetMethodID(clazz,
                "onNativeMessage",
                "(Ljava/lang/String;)V");

        // If method could not be found 如果方法没有找到
        if (NULL == gOnNativeMessage)
        {
            // Get the exception class 获取异常类
            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");

            // Throw exception 抛出异常
            env->ThrowNew(exceptionClazz, "Unable to find method");
        }
    }

exit:
    return;
}

void Java_com_apress_threads_MainActivity_nativeFree (
        JNIEnv* env,
        jobject obj)
{
    // If object global reference is set 如果对象的全局引用已设置
    if (NULL != gObj)
    {
        // Delete the global reference 删除全局引用，以免内存泄漏
        env->DeleteGlobalRef(gObj);
        gObj = NULL;
    }

    // Destory mutex 销毁互斥锁
    if (0 != pthread_mutex_destroy(&mutex))
    {
        // Get the exception class 获取异常类
        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");

        // Throw exception 抛出异常
        env->ThrowNew(exceptionClazz, "Unable to destroy mutex");
    }
}

void Java_com_apress_threads_MainActivity_nativeWorker (
        JNIEnv* env,
        jobject obj,
        jint id,
        jint iterations)
{
    // Lock mutex 锁定互斥锁
    if (0 != pthread_mutex_lock(&mutex))
    {
        // Get the exception class 获取异常类
        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");

        // Throw exception 抛出异常
        env->ThrowNew(exceptionClazz, "Unable to lock mutex");
        goto exit;
    }

    // Loop for given number of iterations 循环给定的迭代数
    for (jint i = 0; i < iterations; i++)
    {
        // Prepare message 准备消息
        char message[26];
        sprintf(message, "Worker %d: Iteration %d", id, i);

        // Message from the C string 来自 C 字符串的消息
        jstring messageString = env->NewStringUTF(message);

        // Call the on native message method 调用原生消息方法
        env->CallVoidMethod(obj, gOnNativeMessage, messageString);

        // Check if an exception occurred 检查是否产生异常
        if (NULL != env->ExceptionOccurred())
            break;

        // Sleep for a second 睡眠 1 秒
        sleep(1);
    }

    // Unlock mutex 解锁互斥锁
    if (0 != pthread_mutex_unlock(&mutex))
    {
        // Get the exception class 获取异常类
        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");

        // Throw exception 抛出异常
        env->ThrowNew(exceptionClazz, "Unable to unlock mutex");
    }

exit:
    return;
}

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

    // Attach current thread to Java virtual machine 将当前线程附加到 Java 虚拟机上
    // and obrain JNIEnv interface pointer 并且获得 JNIEnv 接口指针
    if (0 == gVm->AttachCurrentThread(&env, NULL))
    {
        // Get the native worker thread arguments 获取原生 worker 线程参数
        NativeWorkerArgs* nativeWorkerArgs = (NativeWorkerArgs*) args;

        // Run the native worker in thread context 在线程上下文中运行原生 worker
        Java_com_apress_threads_MainActivity_nativeWorker(env,
                gObj,
                nativeWorkerArgs->id,
                nativeWorkerArgs->iterations);

        // Free the native worker thread arguments 释放原生 worker 线程参数
        delete nativeWorkerArgs;

        // Detach current thread from Java virtual machine 从 Java 虚拟机中分离当前线程
        gVm->DetachCurrentThread();
    }

    return (void*) 1;
}

void Java_com_apress_threads_MainActivity_posixThreads (
        JNIEnv* env,
        jobject obj,
        jint threads,
        jint iterations)
{
    // 线程句柄
    pthread_t* handles = new pthread_t(threads);

    // Create a POSIX thread for each worker 为每一个 worker 创建一个 POSIX 线程
    for (jint i = 0; i < threads; i++)
    {
        // Thread handle 线程句柄
        pthread_t thread;

        // Native worker thread arguments 原生 worker 线程参数
        NativeWorkerArgs* nativeWorkerArgs = new NativeWorkerArgs();
        nativeWorkerArgs->id = i;
        nativeWorkerArgs->iterations = iterations;

        // Create a new thread 创建一个新线程
        int result = pthread_create(
                //&thread,
                &handles[i],
                NULL,
                nativeWorkerThread,
                (void*) nativeWorkerArgs);

        if (0 != result)
        {
            // Get the exception class 获取异常类
            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");

            // Throw exception 抛出异常
            env->ThrowNew(exceptionClazz, "Unable to create thread");
            goto exit;
        }
    }

    // 等待线程中止
    for(jint i = 0; i < threads; i++)
    {
        void* result = NULL;

        // 连接每个线程句柄
        if( 0 != pthread_join( handles[i], &result))
        {
            // Get the exception class 获取异常类
            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");

            // Throw exception 抛出异常
            env->ThrowNew(exceptionClazz, "Unable to create thread");
        }else{
            // 准备 message
            char message[26];
            sprintf(message, "Worker %d returned %d", i, result);

            // 来自 C 字符串的消息
            jstring messageString = env->NewStringUTF(message);

            // 调用原生消息方法
            env->CallVoidMethod(obj, gOnNativeMessage, messageString);

            // 检查是否产生异常
            if (NULL != env->ExceptionOccurred())
            {
                goto exit;
            }
        }
    }
    exit:
        return;
}

使用信号量同步 POSIX 线程

#include <semaphore.h>

// 初始化信号量
extern int sem_init(sem_t* sem, int pshared, unsigned int value);

// 锁定信号量
extern int sem_wait(sem_t* sem);

// 解锁信号量
extern int sem_post(sem_t* sem);

// 销毁信号量
extern int sem_destroy(sem_t* sem);

POSIX 线程调度策略

int pthread_setschedparam(pthread_t thid, int poilcy, struct sched_param const* param);

POSIX Thread 优先级