Mutex lock threads

Question

Am new to multi threaded processs programming  So here s what I need to clarify   Process A code  pthread mutex lock       pthread create fooAPI sharedResource     fooAPI creates another thread with shared resource that shares across processes  pthread mutex unlock     With the above pseudo code  is process B able to access sharedResource if mutex is not unlocked   How can I access the sharedResource from process B correctly   Any there any clear visual diagram that explains the relationship between mutexes  threads and processes

User · Answer

A process consists of at least one thread (think of the main function). Multi threaded code will just spawn more threads. Mutexes are used to create locks around shared resources to avoid data corruption / unexpected / unwanted behaviour. Basically it provides for sequential execution in an asynchronous setup - the requirement for which stems from non-const non-atomic operations on shared data structures.

A vivid description of what mutexes would be the case of people (threads) queueing up to visit the restroom (shared resource). While one person (thread) is using the bathroom easing him/herself (non-const non-atomic operation), he/she should ensure the door is locked (mutex), otherwise it could lead to being caught in full monty (unwanted behaviour)

User · Answer

Q1   Assuming process B tries to take ownership of the same mutex you locked in process A  you left that out of your pseudocode  then no  process B cannot access sharedResource while the mutex is locked since it will sit waiting to lock the mutex until it is released by process A   It will return from the mutex lock   function when the mutex is locked  or when an error occurs    Q2   In Process B  ensure you always lock the mutex  access the shared resource  and then unlock the mutex   Also  check the return code from the mutex lock  pMutex   routine to ensure that you actually own the mutex  and ONLY unlock the mutex if you have locked it   Do the same from process A   Both processes should basically do the same thing when accessing the mutex  lock   If the lock succeeds  then     access sharedResource    unlock      Q3   Yes  there are lots of diagrams     https   www google se search q mutex thread process amp rlz 1C1AFAB enSE487SE487 amp um 1 amp ie UTF-8 amp hl en amp tbm isch amp source og amp sa N amp tab wi amp ei ErodUcSmKqf54QS6nYDoAw amp biw 1200 amp bih 1730 amp sei FbodUbPbB6mF4ATarIBQ

User · Answer

What you need to do is to call pthread mutex lock to secure a mutex  like this   pthread mutex lock  amp mutex     Once you do this  any other calls to pthread mutex lock mutex  will not return until you call pthread mutex unlock in this thread  So if you try to call pthread create  you will be able to create a new thread  and that thread will be able to  incorrectly  use the shared resource  You should call pthread mutex lock from within your fooAPI function  and that will cause the function to wait until the shared resource is available   So you would have something like this    include  lt pthread h gt   include  lt stdio h gt   int sharedResource   0  pthread mutex t mutex   PTHREAD MUTEX INITIALIZER   void  fooAPI void  param        pthread mutex lock  amp mutex       printf  Changing the shared resource now  n        sharedResource   42      pthread mutex unlock  amp mutex       return 0     int main         pthread t thread          Really not locking for any reason other than to make the point      pthread mutex lock  amp mutex       pthread create  amp thread  NULL  fooAPI  NULL       sleep 1       pthread mutex unlock  amp mutex           Now we need to lock to use the shared resource      pthread mutex lock  amp mutex       printf   d n   sharedResource       pthread mutex unlock  amp mutex       Edit  Using resources across processes follows this same basic approach  but you need to map the memory into your other process  Here s an example using shmem    include  lt stdio h gt   include  lt unistd h gt   include  lt sys file h gt   include  lt sys mman h gt   include  lt sys wait h gt   struct shared       pthread mutex t mutex      int sharedResource      int main         int fd   shm open   foo   O CREAT   O TRUNC   O RDWR  0600       ftruncate fd  sizeof struct shared         struct shared  p    struct shared  mmap 0  sizeof struct shared           PROT READ   PROT WRITE  MAP SHARED  fd  0        p- gt sharedResource   0          Make sure it can be shared across processes     pthread mutexattr t shared      pthread mutexattr init  amp shared       pthread mutexattr setpshared  amp shared  PTHREAD PROCESS SHARED        pthread mutex init  amp  p- gt mutex    amp shared        int i      for  i   0  i  lt  100  i              pthread mutex lock  amp  p- gt mutex            printf   d n   p- gt sharedResource           pthread mutex unlock  amp  p- gt mutex            sleep 1              munmap p  sizeof struct shared         shm unlink   foo        Writing the program to make changes to p- sharedResource is left as an exercise for the reader   -   Forgot to note  by the way  that the mutex has to have the PTHREAD PROCESS SHARED attribute set  so that pthreads will work across processes

User · Answer

Below  code snippet  will help you in understanding the mutex-lock-unlock concept  Attempt dry-run on the code   further by varying the wait-time and process-time  you can build you understanding    Code for your reference    include  lt stdio h gt   include  lt pthread h gt   void in progress feedback int    int global   0  pthread mutex t mutex  void  compute void  arg         pthread t ptid   pthread self        printf  ptid    08x  n    int ptid            int i      int lock ret   1         do           lock ret   pthread mutex trylock  amp mutex           if lock ret               printf  lock failed  08x     d   attempt again after 2secs   n    int ptid   lock ret               sleep 2      wait time here            else     ret  0 is successful lock             printf  lock success  08x     d    n    int ptid  lock ret               break                   while lock ret            for  i   0  i  lt  10 10   i             global           do some stuff here     in progress feedback 10      processing-time here        lock ret   pthread mutex unlock  amp mutex       printf  unlocked  08x     d     n    int ptid  lock ret         return NULL     void in progress feedback int prog delay        int i 0      for  i lt prog delay i         printf            sleep 1       fflush stdout              printf   n        fflush stdout      int main void        pthread t tid0 tid1      pthread mutex init  amp mutex  NULL       pthread create  amp tid0  NULL  compute  NULL       pthread create  amp tid1  NULL  compute  NULL       pthread join tid0  NULL       pthread join tid1  NULL       printf  global    d n   global       pthread mutex destroy  amp mutex             return 0

[c] Mutex lock threads

Examples related to c

Examples related to linux

Examples related to pthreads

Examples related to mutex

Examples related to multiprocess