The FFM APIs mentioned by @LouisWasserman are not stable yet. But I did more research and found that the VarHandle API lets us perform atomic store/loads/ops with any memory order of our choice on any Java value: fields, array elements, bytebuffer elements and more.
Note: it's extremely hard to test the correctness of concurrent code, I'm not 100% sure that my answer is memory-safe.
For the sake of simplicity, I'll focus on a release-acquire scenario, but I don't see any reason why atomic_fetch_add wouldn't work. My idea is to share a ByteBuffer between C and Java, since they're made specifically for that. Then you can write all the data you want in the ByteBuffer, and in my specific case about Java-to-C transfer, you can do an atomic release-store to make sure that all data written prior to the atomic store will be visible to anyone acquire-loading the changed "ready" flag. For some reason, using a byte for the flag rather than an int throws an UnsupportedOperationException. The C code can treat the ByteBuffer's backing memory as whatever it wants (such as volatile fields in a struct) and load them using usual atomic functions.
I'm assuming that a good JVM should easily be able to optimise hot ByteBuffer read/stores into simple instructions (not involving method calls), so this approach should definitely be faster than doing JNI calls on AtomicIntegers from the C side. As a final note, atomics are hard to do right, and you should definitely use them only if the performance gain is measurable.
Appendix — sample Java and C code
I don't think StackOverflow supports collapsible sections, sorry for the visual noise.
This example uses a memory map to have shared memory between Java and C, but JNI should work just as well. If using JNI, you should use env->GetDirectBufferAddress to obtain the void* address of a direct ByteBuffer instance's internal buffer.
How to use: Run the Java program first. When it tells you to, run the C program. Go back to the Java console, enter some text and press enter. The C code will print it and exit.
import java.io.IOException;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Scanner;
public class Main {
private static final int MMAP_SIZE = 256;
private static final VarHandle BYTE_BUFFER_INT_HANDLE = MethodHandles.byteBufferViewVarHandle(int[].class, ByteOrder.BIG_ENDIAN);
public static void main(String[] args) throws IOException {
try (var mmapFile = FileChannel.open(Path.of("mmap"), StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.TRUNCATE_EXISTING)) {
assert mmapFile.write(ByteBuffer.wrap(new byte[0]), MMAP_SIZE) == MMAP_SIZE;
var bb = mmapFile.map(FileChannel.MapMode.READ_WRITE, 0, MMAP_SIZE);
// Fill the byte buffer with zeros
for (int i = 0; i < MMAP_SIZE; i++) {
bb.put((byte) 0);
}
bb.force();
System.out.println("You can start the C program now");
// Write the user-inputted string after the first int (which corresponds to the "ready" flag)
System.out.print("> ");
String input = new Scanner(System.in).nextLine();
bb.position(4);
bb.put(StandardCharsets.UTF_8.encode(input));
// When the text has been written to the buffer, release the text by setting the "ready" flag to 1
BYTE_BUFFER_INT_HANDLE.setRelease(bb, 0, 1);
}
}
}
#include <sys/mman.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdatomic.h>
#define MMAP_SIZE 256
#define PAYLOAD_MAX_SIZE (MMAP_SIZE - 4)
typedef struct {
volatile int32_t ready;
char payload[PAYLOAD_MAX_SIZE];
} shared_memory;
int main() {
int mapFile = open("mmap", O_RDONLY);
if (mapFile == -1) {
perror("Error opening mmap file, the Java program should be running right now");
return 1;
}
shared_memory* map = (shared_memory*) mmap(NULL, MMAP_SIZE, PROT_READ, MAP_SHARED, mapFile, 0);
if (map == MAP_FAILED) {
perror("mmap failed");
close(mapFile);
return 1;
}
int ready;
while (!(ready = atomic_load_explicit(&map->ready, memory_order_acquire))) {
sleep(1);
}
printf("Received: %.*s", PAYLOAD_MAX_SIZE, map->payload);
}
I didn't do a whole lot of version testing, but I used to always used to just use Python as my run configuration, even for Flask apps. It seems lately (maybe Python 3.11?), the app crashed with a very similar error when debugging a flask app with that setting. I set the run/debug configuration template as FLASK SERVER, and it worked.
