mutual-exclusion

There are several ways to do this, but I'm not sure which one of them is the best. Here's what I can think of: Look for the process using pgrep. Have the script lock itself using flock, and then check if it is locked each time it runs. Create a pid file in /var/run/program_name.pid and check for existence, and compare pids if needed. There are probably more ways to do this. What do you think is the best approach? There are many ways to do it. PID files are the traditional way to do it. You could also hold a lock on a file, for example the program itself. This small piece of code will do the

I'm using a spin lock to protect a very small critical section. Contention happens very rarely so a spin lock is more appropriate than a regular mutex. My current code is as follows, and assumes x86 and GCC: volatile int exclusion = 0; void lock() { while (__sync_lock_test_and_set(&exclusion, 1)) { // Do nothing. This GCC builtin instruction // ensures memory barrier. } } void unlock() { __sync_synchronize(); // Memory barrier. exclusion = 0; } So I'm wondering: Is this code correct? Does it correctly ensure mutual exclusion? Does it work on all x86 operating systems? Does it work on x86_64

My table has two columns: startsAt endsAt Both hold date and time. I want to make following constraint: IF both columns are NOT NULL then range between startsAt and endsAt must not overlap with other ranges (from other rows). You can keep your separate timestamp columns and still use an exclusion constraint on an expression: CREATE TABLE tbl ( tbl_id serial PRIMARY KEY , starts_at timestamp , ends_at timestamp , EXCLUDE USING gist (tsrange(starts_at, ends_at) WITH &&) -- no overlapping ); Constructing a tsrange value without explicit bounds as tsrange(starts_at, ends_at) automatically assumes

I have two use cases. A. I want to synchronise access by two threads to a queue. B. I want to synchronise access by two threads to a queue and use a condition variable because one of the threads will wait on content to be stored into the queue by the other thread. For use case A I see code example using std::lock_guard<> . For use case B I see code example using std::unique_lock<> . What is the difference between the two and which one should I use in which use case? The difference is that you can lock and unlock a std::unique_lock . std::lock_guard will be locked only once on construction and

Read some texts about locking in PHP. They all, mainly, direct to http://php.net/manual/en/function.flock.php . This page talks about opening a file on the hard-disk!! Is it really so? I mean, this makes locking really expensive - it means each time I want to lock I'll have to access the hard-disk )= Can anymore comfort me with a delightful news? Edit: Due to some replies I've got here, I want to ask this; My script will run only by one thread, or several? Because if it's by one then I obviously don't need a mutex. Is there a concise answer? What exactly I'm trying to do Asked by ircmaxell.

When should one use a semaphore and when should one use a conditional variable (CondVar) ? Locks are used for mutual exclusion. When you want to ensure that a piece of code is atomic, put a lock around it. You could theoretically use a binary semaphore to do this, but that's a special case. Semaphores and condition variables build on top of the mutual exclusion provide by locks and are used for providing synchronized access to shared resources. They can be used for similar purposes. A condition variable is generally used to avoid busy waiting (looping repeatedly while checking a condition)