semaphore

I have a question regarding using Semaphores HANDLE WINAPI CreateSemaphore(...); Is there anyway I can get the current value of the semaphore? No, and that's intentional. Even if you could get the "current" value, that value might very well have changed before you could do anything with it. The only way to do anything with it is to get and set the value atomically -- e.g., wait for the semaphore to be free and set it to "owned" (by that piece of code) in the same operation. Here the solution using Native Api, documented by http://undocumented.ntinternals.net/ . I ommited a few thing because

I'm entering the concurrency programming with some semaphore issues. My function first loads data from server, analyze received info and then, if necessary, makes second request to server. I tried different ways to make it run, none of them did it well. My current code FOR ME seems to be correct, but on second request it just locks(maybe like a DeadLock) and the last log is "<__NSCFLocalDataTask: 0x7ff470c58c90>{ taskIdentifier: 2 } { suspended }" Please, tell me what do I don't know. Maybe there is more elegant way to work with completions for these purposes? Thank you in advance! var users =

According to my understanding, a semaphore should be usable across related processes without it being placed in shared memory. If so, why does the following code deadlock? #include <iostream> #include <semaphore.h> #include <sys/wait.h> using namespace std; static int MAX = 100; int main(int argc, char* argv[]) { int retval; sem_t mutex; cout << sem_init(&mutex, 1, 0) << endl; pid_t pid = fork(); if (0 == pid) { // sem_wait(&mutex); cout << endl; for (int i = 0; i < MAX; i++) { cout << i << ","; } cout << endl; sem_post(&mutex); } else if(pid > 0) { sem_wait(&mutex); cout << endl; for (int i =

What is the proper way to wrap semaphore actions in a try-catch block? What happens if the acquire action is interrupted after it has acquired some number, but not all, of the permits requested? How do you know how many to release again? Should the release go in a "finally" block, but then aren't you possibly releasing permits you didn't get if the action was interrupted? try { lock.acquire(permits); //Do some things that require synchronization //Make sure to release all of the permits again! lock.release(permits); } catch (InterruptedException e) { log.error("Interrupted!"); } The Semaphore

I have a list wrapper that maintains two Tstringlists and a TClassList I need this to be thread safe, such that: Concurrent writes are not allowed (wait state of some sort should be entered) Reading while writing (or vice versa) is not allowed (wait state of some sort should be entered) Concurrent reads are allowed Any ideas on how I can do this? My instinct tells me it needs more than just a critical section, perhaps a semaphore or "usage counter", perhaps one of these in conjunction with a CS. I'm just not quite sure where to start - anything from an overall approach in english to psuedo