For exchanging information between two processes in android, I am using shared memory. But in order to avoid the situation of parallel writing/reading I need some kind of synchronization between those two processes (classical producer-consumer issue).
The standard approach would be to use Semaphores. However they seems to be not supported in Android (see the implementation on https://android.googlesource.com/platform/external/pthreads/+/master/sem_open.c).
After some research I've found out that for the process synchronization the approach with the File Locks could be used (https://developer.android.com/reference/java/nio/channels/FileLock.html). This would be a perfect solution for me, however our apps should not declare WRITE_EXTERNAL_STORAGE/WRITE_EXTERNAL_STORAGE, therefore we cannot lock on the "real" file. I've tried the approach on the locking on the shared memory object itself, by using its File Descriptor. Unfortunately this did not work. It seems that for FileLock the "real" file object is required.
I've done a lot of searching, from what I have found out, most of the classical ipc synchronization mechanisms are not supported and in the Android world the Binder usage is the preferred IPC mechanism.
My question is, how could the Semaphore-like mechanism be implemented with the binder (or any other alternative). Of course we could create AIDL with
- isLocked
- lock
- release
set of methods. But it would mean that there will be "busy waiting" approach needed (before each write/read operation), which we want to avoid.
Are there any synchronization mechanisms/patterns (either Java or NDK) that we could use?