JNI 轮询问题

Question

我编写了一个本机方法，可以从套接字接收数据，然后写回 ByteArray，这是来自 Java 的输入参数。该套接字是在 BlueZ 中创建的，并通过 dBus 消息传输到我的程序。我使用一个单独的线程来完成整个过程。

感谢 Cerber 对我之前的 GetPrimitiveArrayCritical() 问题的建议。现在，程序可以正常运行了。

然而，新的问题是，因为我使用 Poll 来等待 POLLIN 事件，所以如果有传入的数据可供读取，理论上就会有 POLLIN 事件，我可以进行套接字读取。

不幸的是，POLLIN 事件不断触发，但我无法读取任何数据！ 但是当我在 BlueZ 的代码中执行完全相同的过程时，这种奇怪的行为并没有发生。 我确信插座是正确的。

我的本机代码如下：

struct socket_loop_native_data {
        pthread_mutex_t thread_mutex;
        pthread_t thread;
        struct pollfd *pollData;
        JavaVM *vm;
        int envVer;
        jobject me;
        jbyteArray javaBuffer;
        int bufferSize;
        jbyte *nativeBuffer;
        char *beginOfBuffer;
        char *endOfBuffer;
        int decodedDataSize;
        bool running;
};

typedef socket_loop_native_data native_data_t;

static jfieldID field_mNativeDataSocket;

static inline native_data_t *get_native_data(JNIEnv *env, jobject object) {
    return (native_data_t *)(env->GetIntField(object, field_mNativeDataSocket));
}

native_data_t *get_SocketLoop_native_data(JNIEnv *env, jobject object) {
    return get_native_data(env, object);
}

JNIEXPORT void JNICALL Java_android_classInitNativeSocket(JNIEnv* env, jclass clazz) {
    field_mNativeDataSocket = env->GetFieldID(clazz, "mNativeDataSocket", "I");
}

JNIEXPORT void JNICALL Java_android_initializeNativeDataNativeSocket(JNIEnv* env, jobject object) {

    native_data_t *nat = (native_data_t *)calloc(1, sizeof(native_data_t));
    if (NULL == nat) {
        LOGD("%s: out of memory!", __FUNCTION__);
        return;
    }
    memset(nat, 0, sizeof(native_data_t));

    pthread_mutex_init(&(nat->thread_mutex), NULL);

    env->SetIntField(object, field_mNativeDataSocket, (jint)nat);

}

JNIEXPORT jboolean JNICALL Java_android_startSocketLoopNative(JNIEnv *env, jobject object, jint sock, jbyteArray buffer, jint size) {

    jboolean result = JNI_FALSE;

    socket_loop_native_data *nat = get_native_data(env, object);

    pthread_mutex_lock(&(nat->thread_mutex));

    nat->running = false;

    if (nat->pollData) {
        LOGD("trying to start SocketLoop a second time!");
        pthread_mutex_unlock( &(nat->thread_mutex) );
        return JNI_FALSE;
    }

    nat->pollData = (struct pollfd *)malloc(sizeof(struct pollfd));
    if (!nat->pollData) {
        LOGD("out of memory error starting SocketLoop!");
        goto done;
    }

    memset(nat->pollData, 0, sizeof(struct pollfd));

    nat->pollData[0].fd = sock;
    nat->pollData[0].events = POLLIN;

    env->GetJavaVM( &(nat->vm) );
    nat->envVer = env->GetVersion();

    nat->me = env->NewGlobalRef(object);

    nat->javaBuffer = (jbyteArray)(env->NewGlobalRef(buffer));
    nat->bufferSize = (int)size;
    nat->decodedDataSize = 0;

    pthread_create(&(nat->thread), NULL, socketLoopMain, nat);
    result = JNI_TRUE;

done:
    if (JNI_FALSE == result) {
        if (nat->me) env->DeleteGlobalRef(nat->me);
        nat->me = NULL;
        if (nat->pollData) free(nat->pollData);
        nat->pollData = NULL;
    }

    pthread_mutex_unlock(&(nat->thread_mutex));

    return result;
}

static void *socketLoopMain(void *ptr) {

    native_data_t *nat = (native_data_t *)ptr;
    JNIEnv *env;

    JavaVMAttachArgs args;
    char name[] = "SocketLoop";
    args.version = nat->envVer;
    args.name = name;
    args.group = NULL;

    nat->vm->AttachCurrentThread(&env, &args);

    /* For poll result */
    int ret = 0;

    /* For receiving pollin data */
    int rlen;
    char *buffer = (char *)calloc(1, 65536);

    ...

    while ((nat->running)) {

        if ((ret = poll(nat->pollData, 1, -1)) < 0){
            LOGD("In socketLoopMain() : The socket poll error !!!");
            goto close;
        }

            if ((nat->pollData[0].revents & POLLIN)){

                    ...

                rlen = read(nat->pollData[0].fd, buffer, 65536);
                LOGD("In socketLoopMain() : Read bytes = %d", rlen);

                    ...
            }

            else if ((nat->pollData[0].revents & POLLOUT)){
                LOGD("In socketLoopMain() : The socket poll revents [POLLOUT] !!! DO NOTHING");
                continue;
            }
            else if ((nat->pollData[0].revents & POLLERR)){
                LOGD("In socketLoopMain() : The socket poll revents [POLLERR] !!!");
                goto close;
            }
            else if ((nat->pollData[0].revents & POLLHUP)){
                LOGD("In socketLoopMain() : The socket poll revents [POLLHUP] !!!");
                goto close;
            }
            else if ((nat->pollData[0].revents & POLLRDHUP) || (nat->pollData[0].revents & POLLNVAL)){
                LOGD("In socketLoopMain() : The socket poll revents [POLLRDHUP][POLLNVAL] !!!");
                goto close;
            }
    }
    ...
}

除了第一个 POLLIN，我无法从套接字读取任何数据，rlen 始终为 0。

我通过在 Android 源代码根目录中使用命令“make libxxx”将整个本机代码构建到共享库目录不是“ndk-build”。

任何建议将不胜感激！

Answer 1

经过一些实验，我发现（我不确定这是否是正常且正确的行为......）

（1）在JNI中，当客户端本身关闭连接的套接字时，服务器不会意识到这一点。服务器部分将连续接收 POLLIN 事件，但如果我们读取套接字，则读取的字节将为 0！

(2) 在JNI中，当服务器轮询套接字超时并关闭连接的套接字时，客户端不会意识到这一点。如果客户端尝试通过此关闭的套接字发送数据，它将收到返回值 -1。

(3) 在JNI中，如果我使用pthread_create并处理套接字，无论您是否将此线程附加到Java VM，套接字都将无法正常工作！但如果我用 Java 创建线程，并且其他线程保持不变，它就可以工作了！

这就是我发现的。或许，这并不正确。请指出。
任何建议将不胜感激！

Answer 2

这个页面会给你答案。
http://developer.android.com/training/articles/perf-jni.html

1. 你不能在线程之间共享 JNIEnv。
2. 通过 JNI 连接的线程在退出之前必须调用 DetachCurrentThread。