NDK学习笔记(八) 线程相关

最新推荐文章于 2021-05-27 15:26:02 发布
最新推荐文章于 2021-05-27 15:26:02 发布
阅读量330 收藏 1
点赞数
分类专栏： NDK 文章标签： android android studio ndk pthread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011609853/article/details/105331054
版权

文章目录

1.原生线程

(1) 原生代码使用java线程

public class MainActivity extends AppCompatActivity {

    // Used to load the 'native-lib' library on application startup.
    static {
        System.loadLibrary("native-lib");
    }

    EditText threads_edit;
    EditText iterations_edit;
    Button start_button;
    TextView log_view;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        threads_edit = findViewById(R.id.threads_edit);
        iterations_edit = findViewById(R.id.iterations_edit);
        start_button = findViewById(R.id.start_button);
        log_view = findViewById(R.id.log_view);

        start_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                int threads = getNumber(threads_edit, 0);
                int iterations = getNumber(iterations_edit, 0);
                if (threads > 0 && iterations > 0) {

                    startThreads(threads, iterations);
                }
            }
        });
        nativeInit();
    }

    @Override
    protected void onDestroy() {
        nativeFree();
        super.onDestroy();
    }
	//从原生代码中调用，并传值
    public void onNativeMessage(final String message) {

        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                log_view.append(message);
                log_view.append("\n");
            }
        });
    }
	//获取数值
    private static int getNumber(EditText et, int def) {

        int value;
        try {
            value = Integer.parseInt(et.getText().toString());
        } catch (NumberFormatException e) {
            value = def;
        }
        return value;
    }

    private void startThreads(int thread, int iterations) {

        javaThreads(thread, iterations);
    }

	/**
	开启java线程
	*threads 线程数量
	*iterations  循环次数
	*/
    private void javaThreads(int threads, final int iterations) {


        for (int i = 0; i < threads; i++) {

            final int id = i;
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {

                    nativeWorker(id, iterations);
                }
            });
            thread.start();
        }

    }


    /**
     * 初始化原生代码
     */
    private native void nativeInit();

    /**
     * 释放原生资源
     */
    private native void nativeFree();

    /**
     * 原生worker
     */
    private native void nativeWorker(int id, int iterations);
}

原生代码

#include <jni.h>
#include <string>
#include <stdlib.h>
#include <unistd.h>


static jmethodID gOnNativeMessage = NULL;

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


    if (NULL == gOnNativeMessage) {
        jclass clazz = env->GetObjectClass(thiz);
        //获取onNativeMessage方法的id，以备调用
        gOnNativeMessage = env->GetMethodID(clazz, "onNativeMessage", "(Ljava/lang/String;)V");
        if (NULL == gOnNativeMessage) {

            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "没有找到onNativeMessage方法");
        }
    }
}



extern "C"
JNIEXPORT void JNICALL
Java_com_example_testnt_MainActivity_nativeFree(JNIEnv *env, jobject thiz) {
    // TODO: implement nativeFree()
}



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

    for (jint i = 0; i < iterations; i++) {
        char message[26];
        sprintf(message, "Worker %d: Iteration %d", id, i);

        jstring messageString = env->NewStringUTF(message);
        //调用java的onNativeMessage
        env->CallVoidMethod(thiz, gOnNativeMessage, messageString);

        if (NULL != env->ExceptionOccurred()) {

            break;
        }
        sleep(1);
    }
}

在这里插入图片描述

(2) POSIX线程（android）

在原生代码中使用POSIX线程需要的头文件

#include <pthread.h>

int pthread_create(pthread_t* __pthread_ptr, pthread_attr_t const* __attr, void* (*__start_routine)(void*), void*);

指向pthread_t类型变量的指针，函数用该指针返回新线程的句柄。
指向pthread_attr_t 结构的指针形式存在的新现场属性，可以通过该属性指定新线程的栈基址、栈大小、守护大小、调度策略和调度优先级等。
指向线程启动程序的函数指针，启动程序函数签名格式如下：

void* start_rountine(void* args)

实例：
与上面代码有公用部分。
新增native方法posixThreads（），用来创建新线程。
添加NativeWorkerArgs结构体，全局变量JavaVM、jobject，实现nativeFree方法。
新增JNI_OnLoad方法，此方法当共享库开始加载虚拟机自动调用该函数。
新增nativeWorkThread方法，将posix线程正确的附加到java虚拟机上，并将数据传给java。

具体的变动看代码：
java

package com.example.testnt;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    // Used to load the 'native-lib' library on application startup.
    static {
        System.loadLibrary("native-lib");
    }

    EditText threads_edit;
    EditText iterations_edit;
    Button start_button;
    TextView log_view;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        threads_edit = findViewById(R.id.threads_edit);
        iterations_edit = findViewById(R.id.iterations_edit);
        start_button = findViewById(R.id.start_button);
        log_view = findViewById(R.id.log_view);

        start_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                int threads = getNumber(threads_edit, 0);
                int iterations = getNumber(iterations_edit, 0);
                if (threads > 0 && iterations > 0) {

                    //startThreads(threads, iterations);
                    posixThreads(threads, iterations);
                }
            }
        });

        nativeInit();

    }

    @Override
    protected void onDestroy() {
        nativeFree();
        super.onDestroy();
    }

    public void onNativeMessage(final String message) {

        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                log_view.append(message);
                log_view.append("\n");
            }
        });
    }

    private static int getNumber(EditText et, int def) {

        int value;
        try {
            value = Integer.parseInt(et.getText().toString());
        } catch (NumberFormatException e) {
            value = def;
        }
        return value;
    }

    private void startThreads(int thread, int iterations) {

        javaThreads(thread, iterations);
    }

    private void javaThreads(int threads, final int iterations) {


        for (int i = 0; i < threads; i++) {

            final int id = i;
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {

                    nativeWorker(id, iterations);
                }
            });
            thread.start();
        }

    }


    /**
     * 初始化原生代码
     */
    private native void nativeInit();

    /**
     * 释放原生资源
     */
    private native void nativeFree();

    /**
     * 原生worker
     */
    private native void nativeWorker(int id, int iterations);

    /**
     * 使用POSIX线程
     *
     * @param threads
     * @param iterations
     */
    private native void posixThreads(int threads, int iterations);
}

原生代码

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

extern "C"
JNIEXPORT void JNICALL
Java_com_example_testnt_MainActivity_nativeWorker(JNIEnv *env, jobject thiz, jint id,
                                                  jint iterations);

static void *nativeWorkThread(void *args);


//定义结构体
struct NativeWorkerArgs {
    jint id;
    jint iterations;
};
//JAVa虚拟机接口指针
static JavaVM *gVm = NULL;
//对象的全局引用
static jobject gObj = NULL;

static jmethodID gOnNativeMessage = NULL;

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

    //为对象创建一个新的全局引用
    if (NULL == gObj) {
        gObj = env->NewGlobalRef(thiz);
    }
    if (NULL == gObj) {
        //结束此方法
        goto exit;
    }

    if (NULL == gOnNativeMessage) {
        jclass clazz = env->GetObjectClass(thiz);
        //获取onNativeMessage方法的id，以备调用
        gOnNativeMessage = env->GetMethodID(clazz, "onNativeMessage", "(Ljava/lang/String;)V");
        if (NULL == gOnNativeMessage) {

            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "没有找到onNativeMessage方法");
        }
    }

    exit:
    return;
}

/**
 * 当共享库开始加载虚拟机自动调用该函数，可以获取到JavaVM的指针
 * @param vm
 * @param reserved
 * @return
 */
jint JNI_OnLoad(JavaVM *vm, void *reserved) {

    gVm = vm;
    return JNI_VERSION_1_4;
}

//将posix线程正确的附着到java虚拟机上
static void *nativeWorkThread(void *args) {

    JNIEnv *env = NULL;
    //将当前线程附加到java虚拟机上
    if (0 == gVm->AttachCurrentThread(&env, NULL)) {

        //获取原生worker线程参数
        NativeWorkerArgs *nativeWorkerArgs = (NativeWorkerArgs *) args;
        //运行原生worker
        Java_com_example_testnt_MainActivity_nativeWorker(env, gObj, nativeWorkerArgs->id,
                                                          nativeWorkerArgs->iterations);
        delete nativeWorkerArgs;
        gVm->DetachCurrentThread();

    }

    return (void *) 1;
}


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

    if (NULL != gObj) {

        env->DeleteGlobalRef(gObj);
        gObj = NULL;
    }
}



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

    for (jint i = 0; i < iterations; i++) {
        char message[26];
        sprintf(message, "Worker %d: Iteration %d", id, i);

        jstring messageString = env->NewStringUTF(message);
        //调用java的onNativeMessage
        env->CallVoidMethod(thiz, gOnNativeMessage, messageString);

        if (NULL != env->ExceptionOccurred()) {

            break;
        }
        sleep(1);
    }
}

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

    for (jint i = 0; i < threads; i++) {

        NativeWorkerArgs *nativeWorkerArgs = new NativeWorkerArgs();
        nativeWorkerArgs->id = i;
        nativeWorkerArgs->iterations = iterations;

        pthread_t thread;
        //创建一个新线程
        int result = pthread_create(&thread, NULL, nativeWorkThread, (void *) nativeWorkerArgs);
        if (0 != result) {

            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "创建线程失败");
        }
    }

}

为什么要附着在java虚拟机上。由于posix线程不是java平台的一部分，因此虚拟机不能识别他们。为了和java控件交互，posix线程应该先将自己附着到虚拟机上。

(3) 从POSIX线程返回结果

线程终止时，返回一个结果。通过线程启动程序返回的空指针实现的。
将函数修改成等待线程结束后再返回。pthread_join函数可以使一个函数等待线程终止。
紧接上面的代码，做出修改：

extern "C"
JNIEXPORT void JNICALL
Java_com_example_testnt_MainActivity_posixThreads(JNIEnv *env, jobject thiz, jint threads,
                                                  jint iterations) {
    //线程句柄
    pthread_t *handles = new pthread_t[threads];

    for (jint i = 0; i < threads; i++) {

        NativeWorkerArgs *nativeWorkerArgs = new NativeWorkerArgs();
        nativeWorkerArgs->id = i;
        nativeWorkerArgs->iterations = iterations;

        //创建一个新线程
        int result = pthread_create(&handles[i], NULL, nativeWorkThread,
                                    (void *) nativeWorkerArgs);
        if (0 != result) {

            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "创建线程失败");
            goto exit;
        }
    }

    for (jint i = 0; i < threads; i++) {

        void *result = NULL;
        if (0 != pthread_join(handles[i], &result)) {

            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "join");
        } else {

            char message[26];
            sprintf(message, "Worker %d returned %d", i, result);
            jstring messageString = env->NewStringUTF(message);
            env->CallVoidMethod(thiz, gOnNativeMessage, messageString);
            if (NULL != env->ExceptionOccurred()) {

                goto exit;
            }
        }
    }

    exit:
        return;

}

运行后，点击按钮，会明显的感觉到卡了一会，这是由于pthread_join函数将UI的主线程挂起直到创建的线程终止。
效果：
在这里插入图片描述

(4) POSIX线程同步

常用同步机制：

互斥锁确保代码的互斥执行，即代码的特定不封不同时执行。

信号量控制对特定数目可用资源的访问，如果没有可用的资源，调用线程只是在信号量锁涉及的资源是哪个等待，直到资源可用。

①互斥锁

初始化
方式一

int pthread_mutex_init(pthread_mutex_t* __mutex, const pthread_mutexattr_t* __attr);

参数一：指向要初始化的互斥变量的指针
参数二：指向为互斥锁定义属性的pthread_mutexattr_t结构体指针，可设置成NULL，使用默认属性。

方式二

 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

锁定互斥锁

//如果互斥锁已经被锁上，调用线程被挂起直到互斥锁被打开。
//成功返回0，否则返回错误代码
int pthread_mutex_lock(pthread_mutex_t* __mutex);

解锁互斥锁

//如果成功，函数返回0，否则返回错误代码
int pthread_mutex_unlock(pthread_mutex_t* __mutex);

销毁互斥锁

int pthread_mutex_destroy(pthread_mutex_t* __mutex);

修改上面的代码

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

extern "C"
JNIEXPORT void JNICALL
Java_com_example_testnt_MainActivity_nativeWorker(JNIEnv *env, jobject thiz, jint id,
                                                  jint iterations);

static void *nativeWorkThread(void *args);


//定义结构体
struct NativeWorkerArgs {
    jint id;
    jint iterations;
};
//JAVa虚拟机接口指针
static JavaVM *gVm = NULL;
//对象的全局引用
static jobject gObj = NULL;

static jmethodID gOnNativeMessage = NULL;

//互斥锁
static pthread_mutex_t mutex;

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

    //初始化互斥
    mutex = PTHREAD_MUTEX_INITIALIZER;
/*    if (0 != pthread_mutex_init(&mutex, NULL)) {
        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
        env->ThrowNew(exceptionClazz, "没有初始化互斥锁");
        goto exit;
    }*/

    //为对象创建一个新的全局引用
    if (NULL == gObj) {
        gObj = env->NewGlobalRef(thiz);
    }
    if (NULL == gObj) {
        //结束此方法
        goto exit;
    }

    if (NULL == gOnNativeMessage) {
        jclass clazz = env->GetObjectClass(thiz);
        //获取onNativeMessage方法的id，以备调用
        gOnNativeMessage = env->GetMethodID(clazz, "onNativeMessage", "(Ljava/lang/String;)V");
        if (NULL == gOnNativeMessage) {

            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "没有找到onNativeMessage方法");
        }
    }

    exit:
    return;
}

/**
 * 当共享库开始加载虚拟机自动调用该函数，可以获取到JavaVM的指针
 * @param vm
 * @param reserved
 * @return
 */
jint JNI_OnLoad(JavaVM *vm, void *reserved) {

    gVm = vm;
    return JNI_VERSION_1_6;
}

//将posix线程正确的附着到java虚拟机上
static void *nativeWorkThread(void *args) {

    JNIEnv *env = NULL;
    //将当前线程附加到java虚拟机上
    if (0 == gVm->AttachCurrentThread(&env, NULL)) {

        //获取原生worker线程参数
        NativeWorkerArgs *nativeWorkerArgs = (NativeWorkerArgs *) args;
        //运行原生worker
        Java_com_example_testnt_MainActivity_nativeWorker(env, gObj, nativeWorkerArgs->id,
                                                          nativeWorkerArgs->iterations);
        delete nativeWorkerArgs;
        gVm->DetachCurrentThread();

    }

    return (void *) 1;
}


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

    if (NULL != gObj) {

        env->DeleteGlobalRef(gObj);
        gObj = NULL;
    }
    //销毁互斥锁
    if (0 != pthread_mutex_destroy(&mutex)) {

        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
        env->ThrowNew(exceptionClazz, "不能都销毁互斥锁");
    }
}



extern "C"
JNIEXPORT void JNICALL
Java_com_example_testnt_MainActivity_nativeWorker(JNIEnv *env, jobject thiz, jint id,
                                                  jint iterations) {
    //锁定互斥锁
    if (0 != pthread_mutex_lock(&mutex)) {

        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
        env->ThrowNew(exceptionClazz, "不能锁定");
        goto exit;
    }

    for (jint i = 0; i < iterations; i++) {
        char message[26];
        sprintf(message, "Worker %d: Iteration %d", id, i);

        jstring messageString = env->NewStringUTF(message);
        //调用java的onNativeMessage
        env->CallVoidMethod(thiz, gOnNativeMessage, messageString);

        if (NULL != env->ExceptionOccurred()) {

            break;
        }
        sleep(1);
    }

    //解锁互斥锁
    if (0 != pthread_mutex_unlock(&mutex)) {

        jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
        env->ThrowNew(exceptionClazz, "不能解锁");
    }
    exit:
    return;
}

extern "C"
JNIEXPORT void JNICALL
Java_com_example_testnt_MainActivity_posixThreads(JNIEnv *env, jobject thiz, jint threads,
                                                  jint iterations) {
    //线程句柄
    pthread_t *handles = new pthread_t[threads];

    for (jint i = 0; i < threads; i++) {

        NativeWorkerArgs *nativeWorkerArgs = new NativeWorkerArgs();
        nativeWorkerArgs->id = i;
        nativeWorkerArgs->iterations = iterations;

        //创建一个新线程
        int result = pthread_create(&handles[i], NULL, nativeWorkThread,
                                    (void *) nativeWorkerArgs);
        if (0 != result) {

            jclass exceptionClazz = env->FindClass("java/lang/RuntimeException");
            env->ThrowNew(exceptionClazz, "创建线程失败");
        }
    }
}

效果
在这里插入图片描述
可以明显的看到线程1执行完，线程0才能执行。

②使用信号量同步

需要使用头文件

#include <semaphore.h>

初始化信号量

信号量指针、共享标志、初始值
int sem_init(sem_t* __sem, int __shared, unsigned int __value);

锁定信号量

如果信号量的值大于零，上锁成功，并且信号量的值也会相应递减。
如果信号量的值是零，调用线程被挂起，直到另一个线程通过解锁它增加了信号量的值。
成功0  失败-1
int sem_wait(sem_t* __sem);

解锁信号量

当使用sem_post函数解锁信号量以后，信号量的值会增加1.
成功0  失败-1
int sem_post(sem_t* __sem);

销毁信号量

销毁一个线程正在阻塞的信号量有可能导致未知问题。
int sem_destroy(sem_t* __sem);

(5) POSIX线程调度策略

  • SCHED_FIFO：先进先出调度策略基于线程进入列表的时间对线程进行排序，也可以基于优先级在列表中移动线程。
  • SCHED_RR:循环轮转调度策略是线程执行时间加以限制的SCHED_FIFO，起目的是避免线程独占可用的CPU时间。

调度策略在头文件中

#include <sched.h>

如何使用？

  • 用pthread_create函数创建一个新线程时，用线程属性结构pthread_attr_t的sched_policy域来定义调度策略。
  • 在运行时用pthread_setschedparam函数定义调度策略
来来走走
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android NDK（八）：JNI多线程
...
03-24 6860
今天来唠唠JNI中关于多线程。多线程，即多个线程同时工作，多线程的问题比较复杂，在实际情况下可能会面临众多的问题。JNI中也提供了一系列函数帮助我们完成多线程交互。博客内容大致分为如下：  1. 同步代码块  2. 等待唤醒 本篇内容可能介绍的比较浅显，更多的东西还需要大家再实战中去慢慢体会。 一、同步代码块 如果本地代码要运行在多个线程环境中，可能会面临同时共享资源的情况。
二，Ndk开发【线程】
最新发布
qq_32667685的博客
08-12 345
ndk，多线程，pthread,JNIEnv,JavaVM
android ndk sleep,android ndk 线程使用与sleep
weixin_28913137的博客
05-27 441
#include #include // sleep 的头文件#include pthread_cond_t cond;pthread_mutex_t mutex;struct timeval now;struct timespec outtime;// 单位毫秒void LTSleep(int nHm) {gettimeofday(&now, NULL);now.tv_usec += ...
Android NDK学习 <一> 简介
amor2006的专栏
11-22 606
Android NDK( Native Developer Kit )是个工具集，它提供一套方法，使Android应用程序(Java程序)可以内嵌native（C,C++）程序。 Android应用程序(Java程序)运行于Dalvik虚拟机中。NDK允许应用程序的一部分使用native语言(C,C++)来实现。这对很多程序都是有帮助的，比如需要利用以前完成的C，C++代码，也可以提高运
Android NDK pthreads详细使用
z979451341的博客
03-02 5030
这个pthread.h文件可以在NDK环境里创建子线程，并对线程能够做出互斥所、等待、销毁等控制。写这个博客的原因是我要写如何使用FFmpeg播放视频，因为同时需要播放音频和视频所以需要开启线程，并设置生产者和消费者的关系。好了直接上整体1.开启和销毁线程pthread_create函数能够创建线程，第一个参数是线程的引用，第二个是线程的属性，一般为NULL，第三个为线程运行的函数，第四个是给线程...
NDK_DEMO:CC ++开发学习笔记
03-29
《NDK_DEMO：CC++开发学习笔记》 在Android应用开发中，NDK（Native Development Kit）是一个不可或缺的工具，它允许开发者使用C和C++编写底层代码，以实现高性能、低级别的系统操作和硬件访问。这篇学习笔记将深入...
Android ROM定制学习笔记
03-23
Android ROM 定制学习笔记 Android ROM 定制学习笔记是一份详细的学习笔记，旨在指导读者如何安装和配置 Android 的底层开发环境，并编译官方的 Android 源代码和 Linux 内核源代码。该笔记还将指导读者如何将编译...
BlogApp:志哥博客《OpenGL.ES在Android上的简单实践》《NDK学习笔记》专栏demo工程
05-26
**NDK学习笔记** NDK（Native Development Kit）是Android开发的一部分，它允许开发者使用C和C++编写原生代码。这在需要高性能计算、利用硬件加速或复用现有C/C++库时特别有用。例如，游戏引擎、音频/视频处理库...
android-JNI学习笔记
10-19
《Android JNI 学习笔记》 JNI，全称为Java Native Interface，是Java平台提供的一种技术，允许Java代码和其他语言写的代码进行交互。JNI在Android开发中扮演着重要角色，尤其是在需要调用本地库、优化性能或者实现...
NDK Sleep Connect
04-18
NDK Sleep Connect
pthread_cancel()　NDK不支持
Keivin
12-09 3690
pthread_cancel() 我用cmake在ndk环境下编译，pthread库没有这个函数，我原以为是cmake的问题，后来查明是 NDK不支持　.. 只能用  pthread_kill  //pthread_join和pthread_detch好像停不了线程
c++ for Android ----- ndk 编译链接 pthread 报错
刘长福
01-30 2712
按正常的对c++的库文件引用，Android.mk文件应该这么写： … LOCAL_LDLIBS += -lpthread LOCAL_LDLIBS += -llog … 但是好端端的却报错误： *****non-system libraries in linker flags: -lpthread *********error: cannot find -lpthread 使用find命令也能...
android ndk not support pthread_cancel
typename 记录点滴
08-05 8533
转载请注明：  http://blog.csdn.net/typename/article/details/7794958 下面是google关于这个问题的说法： Try changing your code so that your threads don't get stuck waiting indefinitely for i/o. For example used condit
Android NDK使用之--用pthread实现多线程
jike0901xuye的专栏
12-16 5225
Android系统本身包括Java和Linux内核；因此在Android应用中实现多线程就可以是基于Java上的和基于Linux上的；今天本文介绍的就是Android利用Linux下的pthread来实现多线程；大概思路如下： 我们将异步任务需要实现的方法在Java中定义，但是运行异步任务的线程交给pthread实现； 因此首先设计一个接口，作为异步任务的业务接口
linux下c++sleep函数
线上幽灵
04-26 9391
sleep() 秒级 usleep() 微秒级 #include <iostream> #include <unistd.h> using namespace std; int main(){ while(1) { cout << "hello" << endl; //sleep(1); usleep...
android sleep
热门推荐
liuzhen007的专栏
05-23 1万+
代码实例，单位毫秒：try{    Thread.sleep(2000);}catch (Exception e ){}
NDK实现后台服务保活
sinduanan的博客
06-13 1555
现在的国产手机基本都是不能保证的 随随便便一杀就没了 复活不了；我的华为P9就不行，其他的我觉得也够呛，但是使用公司自己得MTK5.0平台， 那真是特吗和病毒没什么区别。。。 我这是在腾讯课堂里学习来得；动脑学院，挺好得一个学习android看视频得地方； 1： java方式守护 AndroidMainfast.xml 中定义process = “：remote”字段； 手机厂商...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值