Thread concurrency in linux

Question

I am beginner to SO, so please let me know if the question is not clear.

I am using two threads for example A and B. And i have a global variable 'p'. Thread A is while looping and incrementing the value of 'p'.At the same time B is trying to set the 'p' with some other value(both are two different thread functions).

If I am using mutex for synchronizations, and the thread A get the mutex and incrementation the 'p' in a while loop,but it does not release the mutex. So my question is that if the thread A doesn’t release the mutex can the thread B access the variable 'p'??

EDIT The thread B is also protected accses to 'p' using mutex.

If the thread A lock using pthread_mutex_lock(), and doesn’t release it , then what happen if the same thread(A) try to access the lock again(remember the thread A is while looping) For example

   while(1)
        {
            pthread_mutex_lock(&mutex);
            p = 10;

        }

Is there any problem with this code if the mutex is never released?

Answer 1

Simple example of statically initialized mutex

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

static int p = 0;
static pthread_mutex_t locker = PTHREAD_MUTEX_INITIALIZER;

static void *
threadFunc(void *arg)
{
  int err;
  err = pthread_mutex_lock(&locker);
  if (err != 0){
    perror("pthread_mutex_lock failed");
    exit(1);
  }
  p++;
  err = pthread_mutex_unlock(&locker);
  if (err != 0){
    perror("pthread_mutex_unlock failed");
    exit(1);
  }
  return NULL;
}

int
main(int argc, char *argv[])
{
  pthread_t A, B;
  pthread_create(&A, NULL, threadFunc, NULL);
  pthread_create(&B, NULL, threadFunc, NULL);
  pthread_join(A, NULL);
  pthread_join(B, NULL);
  printf("p = %d\n", p);
  return 0;
}

Error checking in main is omitted for brevity but should be used. If you do not release mutex program will never finish, thread B will never get lock.

Answer 2

There is no restriction on mutex, you need to write your program to following the rules of using mutex.

Here is the basic steps to use mutex on shared resource:

• Acquire lock first
• do job (increase for A, set value for B)
• Release lock,

If both A & B follow the rules, then B can't modify it, while A keeps the lock.

Or, if your thread B don't acquire the lock first, it of cause could modify the variable, but that would be a bug for concurrent programming.

And, by the way, you can also use condition together with mutex, so that you can let threads wait & notify each other, instead of looping all the time which is a waste of machine resource.

---

For your updated question

On linux, in c, there are mainly 3 methods to acquire lock of mutex, what happens when a thread can't get the lock depends on which methods u use.

• int pthread_mutex_lock(pthread_mutex_t * mutex );

if it's already locked by another thread, then it block until the lock is unlocked,

• int pthread_mutex_trylock(pthread_mutex_t * mutex );

similar to pthread_mutex_lock(), but it won't block, instead return error EBUSY,

• int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex, const struct timespec *restrict abs_timeout);

similar to pthread_mutex_lock(), but it will wait for a timeout before return error ETIMEDOUT,

Answer 3

You can still access the variable in thread B as the mutex is a separate object not connected to the variable. If You call mutex lock from thread B before accessing p then the thread B will wait for mutex to be released. In fact the thread A will only execute loop body once as it will wait for the mutex to be released before it can lock it again.

If You don't unlock the mutex then any call to lock the same mutex will wait indefinitely, but the variable will be writable.

In Your example access to variable p is what is called a critical section, or the part of code that is between mutex lock and mutex release.