mutual-exclusion

For concurrency and ensuring the integrity of the data, how would you obtain a mutual-exclusion lock for a given object? Would you need to use locking within the database, or a file, or does PHP support something like this? PHP doesn't support multithreading so there's no locking mechanism for objects. If you want to lock a file you could use flock for that. There's no need to lock database as database engines usually can handle multiple connections. Bare in mind PHP is not multithreaded, so it's unlikely you need anything like this... however, may be needed if you use shared memory, or any

I define mutual exclusion and deadlock as below, respectively: The mutual exclusion condition exists if at every moment, each shared resource is either assigned to exactly one process, or available. A set of processes is deadlocked if each process in the set is waiting for an event that only another process in the set can cause. Say, binary semaphores are used, ensuring that only one of them can enter its critical region at the same time. Since each process does a down just before entering its critical region and an up just after leaving it, mutual exclusion is guaranteed. I understand there

I have a problem regarding the behaviour of the pthread function pthread_rwlock_wrlock . The specification linked above states that when one thread has locked the lock for writing and the same thread locks it again, it results in undefined behaviour (I could actually observe this in that on x86 Linux calling this function is a noop and on PowerPC Linux it stalls the thread). The behaviour I need would be a read write lock that has the following characteristics: read-locking by a thread succeeds if: the lock is not held by any thread the lock is only read-locked by zero or more threads

I need to solve a locking problem for this scenario: A multi CPU system. All of the CPU's use a common (software) resource. Read only access to the resource is very common. (Processing of incoming network packets) Write access is a lot less frequent. (Pretty much configuration changes only). Currently I use the read_lock_bh , write_lock_bh (spinlocks) mechanism. The problem is that the more CPU's, the more I get soft lockups in a writer context. I read the concurrency chapter in this book , But couldn't quite understand whether the reader or the writer will get priority when using spin locks.

I have a shared-memory between multiple threads. I want to prevent these threads access this piece of memory at a same time. (like producer-consumer problem) Problem : A thread add elements to a queue and another thread reads these elements and delete them. They shouldn't access the queue simultaneously. One solution to this problem is to use Mutex. As I found, there is no Mutex in Swift. Is there any alternatives in Swift? As people commented (incl. me), there are several ways to achieve this kind of lock. But I think dispatch semaphore is better than others because it seems to have the least

I found a fairly simple n-process mutual exclusion algorithm on page 4 (836) in the following paper: "Mutual Exclusion Using Indivisible Reads and Writes" by Burns and Lynch program Process_i; type flag = (down, up); shared var F : array [1..N] of flag; var j : 1..N; begin while true do begin 1: F[i] := down; 2: remainder; (* remainder region *) 3: F[i] := down; 4: for j := 1 to i-1 do if F[j] = up then goto 3; 5: F[i] := up; 6: for j := 1 to i-1 do if F[j] = up then goto 3; 7: for j := i+1 to N do if F[j] = up then goto 7; 8: critical; (* critical region *) end end. I like it, because of its