问题简介

我通过 JNI 在一个进程中使用 C++ 和 Java。对于有问题的用例，C++ 线程和 Java 线程都在访问相同的数据，它们是在 C++ 端这样做的，我想正确同步访问。

到目前为止，我几乎所有的 JNI 线程同步都在 Java 端，答案很明显:使用提供的 Java 并发包和内置的并发语言功能。不幸的是，答案在 C++ 方面并不是那么明显。

到目前为止我尝试过的内容简介

我尝试使用 pthreads 互斥锁，认为即使我没有使用 pthreads 来创建线程它也可以工作，但是在尝试锁定时偶尔会卡住 - 我将在下面进一步展示一个示例。

问题详情

在我目前的特定用法中，c++ 正在轮询 Java 提供的更改，以 1 秒计时器(不是我想要的，但我不确定如何使其成为事件驱动的，因为遗留 c++ 代码的性质) )。 Java 线程通过调用 native 函数提供数据，c++ 将数据复制到 c++ 结构中。

这是代码中的情况类型(发生在 2 个线程上，Thread1 和 Thread2):

代码示例

请注意一个 SSCCE，因为它缺少 TheData 的定义和 TheDataWrapper ，但它们包含什么并不重要。假设它们只包含几个公共(public) int如果这有助于您的思考过程(不过，在我的情况下，它实际上是多个 int 数组和 float 数组)。

C++:

class objectA
{
    void poll();
    void supplyData(JNIEnv* jni, jobject jthis, jobject data);
    TheDataWrapper cpp_data;
    bool isUpdated;

    void doStuff(TheDataWrapper* data);
};

// poll() happens on a c++ thread we will call Thread1
void objectA :: poll()
{
    // Here, both isUpdated and cpp_data need synchronization

    if(isUpdated)
    {
        do_stuff(&cpp_data);
        isUpdated = false;
    }
}

// supplyData happens on the Thread2, called as a native function from a java thread
void objectA :: supplyData(JNIEnv* jni, jobject jthis, jobject data)
{
    // some operation happens that copies the java data into a c++ equivalent
    // in my specific case this happens to be copying ints/floats from java arrays to c++ arrays
    // this needs to be synchronized
    cpp_data.copyFrom(data);
    isUpdated = true;
}

class ObjectB
{
    // f() happens on a Java thread which we will call Thread2
    public void f()
    {
        // for the general case it doesn't really matter what the data is
        TheData data = TheData.prepareData();
        supplyData(data);
    }

    public native void supplyData(TheData data);
}

class objectA
{
    pthread_mutex_t dataMutex;
    ... // everything else mentioned before
}

// called on c++ thread
void objectA :: poll()
{
    pthread_mutex_lock(&dataMutex);

    ... // all the poll stuff from before

    pthread_mutex_unlock(&dataMutex);
}

// called on java thread
void objectA :: supplyData(JNIEnv* jni, jobject jthis, jobject data)
{
    pthread_mutex_lock(&dataMutex);

    ... // all the supplyData stuff from before

    pthread_mutex_unlock(&dataMutex);
}

最佳答案

如果两个线程都附加到 JVM，那么您可以通过 JNIEnv 访问 JNI 的同步。的 MonitorEnter(jobject)和 MonitorExit(jobject)职能。就像听起来一样，MonitorEnter获得对提供的 jobject 的锁定, 和 MonitorExit释放对提供的 jobject 的锁.

注意:有一些陷阱需要注意!注意 MonitorEnter 的倒数第二段的描述和MonitorExit的最后一段关于混搭的说明MonitorEnter/MonitorExit与您可能认为兼容的其他类似机制。

见 here

MonitorEnter

jint MonitorEnter(JNIEnv *env, jobject obj);

Enters the monitor associated with the underlying Java object referred to by obj. Enters the monitor associated with the object referred to by obj. The obj reference must not be NULL. Each Java object has a monitor associated with it. If the current thread already owns the monitor associated with obj, it increments a counter in the monitor indicating the number of times this thread has entered the monitor. If the monitor associated with obj is not owned by any thread, the current thread becomes the owner of the monitor, setting the entry count of this monitor to 1. If another thread already owns the monitor associated with obj, the current thread waits until the monitor is released, then tries again to gain ownership.

A monitor entered through a MonitorEnter JNI function call cannot be exited using the monitorexit Java virtual machine instruction or a synchronized method return. A MonitorEnter JNI function call and a monitorenter Java virtual machine instruction may race to enter the monitor associated with the same object.

To avoid deadlocks, a monitor entered through a MonitorEnter JNI function call must be exited using the MonitorExit JNI call, unless the DetachCurrentThread call is used to implicitly release JNI monitors.

LINKAGE:

Index 217 in the JNIEnv interface function table.

PARAMETERS:

env: the JNI interface pointer.

obj: a normal Java object or class object.

RETURNS:

Returns “0” on success; returns a negative value on failure.

MonitorExit

jint MonitorExit(JNIEnv *env, jobject obj);

The current thread must be the owner of the monitor associated with the underlying Java object referred to by obj. The thread decrements the counter indicating the number of times it has entered this monitor. If the value of the counter becomes zero, the current thread releases the monitor.

Native code must not use MonitorExit to exit a monitor entered through a synchronized method or a monitorenter Java virtual machine instruction.

LINKAGE:

Index 218 in the JNIEnv interface function table.

PARAMETERS:

env: the JNI interface pointer.

obj: a normal Java object or class object.

RETURNS:

Returns “0” on success; returns a negative value on failure.

EXCEPTIONS:

IllegalMonitorStateException: if the current thread does not own the monitor.

class objectA
{
    jobject dataMutex;
    ... // everything else mentioned before
}

// called on c++ thread
void objectA :: poll()
{
    // You will need to aquire jniEnv pointer somehow just as usual for JNI
    jniEnv->MonitorEnter(dataMutex);

    ... // all the poll stuff from before

    jniEnv->MonitorExit(dataMutex);
}

// called on java thread
void objectA :: supplyData(JNIEnv* jni, jobject jthis, jobject data)
{
    // You will need to aquire jniEnv pointer somehow just as usual for JNI
    jniEnv->MonitorEnter(dataMutex);

    ... // all the supplyData stuff from before

    jniEnv->MonitorExit(dataMutex);
}

关于java - 如何在 JNI 环境的 native 端正确同步线程？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44420937/