Currently, shared semaphores can only be created, and existing semaphores can't be opened. Shared semaphores are opened using the following command.
```
sem_open(name, O_CREAT | O_EXCL, 0600, val)
```
This will raise error if a semaphore which already exists.
This behaviour works well when the file descriptors of these semaphores can be shared with children processes.

But, it doesn't work when an unrelated process which needs access to shared semaphore tries to open it.

Please give an example of how this is a problem in using Python. You don't give any context here.

Let's say I have two processes which are accessing a shared resource (let's say shared memory). Now, these two processes will need some kind of synchronisation mechanism, to be able to access the resource properly, and avoid race condition.

Currently, shared semaphores can be shared with child processes, but there is no way of accessing a named shared semaphore by two separate processes.

Although, the semaphore created by default is a named semaphore, and has the potential to be accessed by multiple processes, but because of the flags, it can't be opened by any other process.

This is a feature request, and not a bug, therefore I have selected type as enhancement.

A common use for the same can be shared memory. Currently shared memory can be used by unrelated processes, but there is no mechanism as such to synchronise them at the moment.

@ned.deily any thoughts?

I can start working on it.

Ido

@taleinat what do you think?

I'm not convinced there is enough real need for this to justify implementing and supporting it.

Using shared memory wouldn't be possible with built-in Python objects; one would have to use a special-purpose library for this, or perhaps use something like ctypes. It seems to me that in any case, once someone is doing those, they might as well use those same tools to also create and manage shared resources such as shared memory.

Therefore, even if we allow creating such shared resources, it doesn't seem to me that they will be very usable without a lot of extra supporting features.

In other words, I'd like to see at least one convincing use-case for this before considering any implementation.

Hi,
I think a use case for this is https://docs.python.org/3/library/multiprocessing.shared_memory.html

If not, can you please suggest a way to synchronise the above across unrelated processes.

Sorry this hasn't been followed up. I think this would best be discussed a bit on the Python-Ideas mailing list. Please send an email there suggesting this feature, and link to the discussion thread in the mailing list archives here.

As suggested I have sent a mail to Python Ideas regarding this issue.
Link to Python Ideas Archive: https://mail.python.org/archives/list/python-ideas@python.org/thread/X4AKFFMYEKW6GFOUMXMOJ2OBINNY2Q6L/

Hi @taleinat, I had sent a mail to the python mailing list as suggested. And till now it has received rather positive comments, in the sense that people who responded see this is a useful feature to be integrated into python.