mutex

I'm mostly familiar with Java, C and C++ in which there are ways to control that only one thread is accessing a resource at any given time. Now I'm in search for something similar but in PHP 5.x. To formulate my problem with one example: I have an ASCII-file which only stores a number, the value of a page load counter. At application deployment the file will simply hold a 0. For each access the value will be incremented by one. The goal is to keep track of page loads. The problem comes when many users are concurrently accessing the page containing the counter. When thread A has read the

Windows Mutex seems to allow an acquired lock to be acquired again (recursively) if the thread currently owning the lock tries to acquire it. But, posix based pthread locks don't allow such a behaviour. Is there any compile time macro or any settings which can make the windows mutex behave in the same way as the pthread mutex? As long as you program in Windows, avoid reimplementing the behavior of its Mutex. It being re-entrant by the same thread is absolutely essential for its defined behavior. A sync object without thread affinity is a semaphore that counts to 1. Use CreateSemaphore(). Fwiw,

Is there a well defined behavior for POSIX mutex ownership in case of Thread exits Thread crashes Thread crashes due to exception Suppose thread-1 owns a mutex. And thread-2 is waiting to acquire the same mutex. And thread-1 goes the 1/2/3 scenario. What is the effect on thread-2 ? PS : I believe the behavior for spin-lock is, NOT to unblock thread-2, with reasoning that the section protected by spin-lock is in bad shape anyways. If you're worried about these issues, Robust Mutexes may be the tool you're looking for: http://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_mutexattr

Using the topic Overview - Handle Enumeration , number 5, the attempt Close mutex of another process and and information from Mutex analysis, the canary in the coal mine and discovering new families of malware/ , I have came up with: Attempt 1: http://pastebin.com/QU0WBgE5 You must open Notepad first. Needless to say, this is not working for me. I need better error checking to figure out what's going on. I don't know how to get mutex pointers in the format I see them in Process Explorer . My goal is to be able to delete/kill of the mutex handles created by a process so more than one instance

Do all mutex implementations ultimately call the same basic system/hardware calls - meaning that they can be interchanged? Specifically, if I'm using __gnu_parallel algorithms (that uses openmp ) and I want to make the classes they call threadsafe may I use boost::mutex for the locking? or must I write my own mutex such as the one described here //An openmp mutex. Can this be replaced with boost::mutex? class Mutex { public: Mutex() { omp_init_lock(&_mutex); } ~Mutex() { omp_destroy_lock(&_mutex); } void lock() { omp_set_lock(&_mutex); } void unlock() { omp_unset_lock(&_mutex); } private: omp

I have 3 process (equal priority) P1 P2 P3(timer) priority to get the mutex is as follows: P1(1 priority), P2(2 priority), P3(timer)(3 priority) If suppose p3 comes and get the mutex then p2 comes and wait for mutex after that p1 comes and it also wait for mutex if p3 release mutex then p1 should get the mutex not p2 . How to perform this in C or C++. Note : all processes are running inside threads having same priority. OS - windows Xp Since the threads have equal priority, which thread gets the lock will be rather arbitrary. It appears you want to wait on a condition variable rather than

Related to this question , what is the best practice for naming a mutex? I realize this may vary with OS and even with version (esp for Windows), so please specify platform in answering. My interest is in Win XP and Vista. Sam Saffron A really safe name for a global mutex is <a description> + <a GUID> : MyApp Single Instance Mutex : {c96f7db4-d743-4718-bef0-8533a198bcca} By using a name like this there is absolutely no chance someone else will use the same mutex name as your mutex. Sniffing around with process explorer, you can see that GUIDs are used in a few places, though in general they

I have a big problem, I can't figure out why mutexes in C don't work as I expect. This is my code: #include <stdlib.h> #include <stdio.h> #include <pthread.h> pthread_t mythread; pthread_mutex_t mymutex; void *anotherFunc(void*) { pthread_mutex_lock(&mymutex); for(int i = 0; i < 100; i++) printf("anotherFunc\n"); pthread_mutex_unlock(&mymutex); pthread_exit(NULL); } void *func(void*) { pthread_mutex_lock(&mymutex); for(int i = 0; i < 100; i++) printf("func\n"); pthread_mutex_unlock(&mymutex); pthread_exit(NULL); } int main(int argc, char *argv[]) { pthread_mutex_init(&mymutex, NULL); pthread