Thread hangs in pthread_rwlock_t - c++

Question

I have this simple thread creation progrm in c++, during when a RW lock is declared globally, progrmm executes as expected, but when the same lock declaration is made local (i.e., Inside the function) only one thread executes, the other thread hangs.
WORKING:
#include <iostream>
#include <pthread.h>
using namespace std;
int i = 0;
**pthread_rwlock_t mylock;** //GLOBAL
void* IncrementCounter(void *dummy)
{
cout << "Thread ID " << pthread_self() << endl;
int cnt = 1;
while (cnt < 50)
{
pthread_rwlock_wrlock(&mylock);
++i;
pthread_rwlock_unlock(&mylock);
++cnt;
cout << "Thread ID ( " << pthread_self() << " ) Incremented Value : " << i << endl;
}
}
int main()
{
pthread_t thread1,thread2;
int ret, ret1;
ret = pthread_create(&thread1,NULL,IncrementCounter,NULL);
ret1 = pthread_create(&thread2,NULL,IncrementCounter,NULL);
pthread_join(thread1,NULL);
pthread_join(thread2,NULL);
}
*NON WORKING:*
#include <iostream>
#include <pthread.h>
using namespace std;
int i = 0;
void* IncrementCounter(void *dummy)
{
cout << "Thread ID " << pthread_self() << endl;
int cnt = 1;
**pthread_rwlock_t mylock;** //LOCAL
while (cnt < 50)
{
pthread_rwlock_wrlock(&mylock);
++i;
pthread_rwlock_unlock(&mylock);
++cnt;
cout << "Thread ID ( " << pthread_self() << " ) Incremented Value : " << i << endl;
}
}
int main()
{
pthread_t thread1,thread2;
int ret, ret1;
ret = pthread_create(&thread1,NULL,IncrementCounter,NULL);
ret1 = pthread_create(&thread2,NULL,IncrementCounter,NULL);
pthread_join(thread1,NULL);
pthread_join(thread2,NULL);
}
What could be the possible reason for this?

Answer 1

In neither case are you correctly initialising the mylock variable - you are just getting "lucky" in the first case. The correct initialisation in the global case would be:
pthread_rwlock_t mylock = PTHREAD_RWLOCK_INITIALIZER;
In the local case, if you want your threads to be accessing the same lock, then it has to be declared static:
static pthread_rwlock_t mylock = PTHREAD_RWLOCK_INITIALIZER;
That's what you want in this case, because you're protecting access to the global i. The lock should be associated with the data, so if i is global then really it makes sense for mylock to be global also.
If you really wanted non-static locks (which in this case, you don't), you would use:
pthread_rwlock_t mylock;
pthread_rwlock_init(&mylock, NULL);
followed by:
pthread_rwlock_destroy(&mylock);
at the end of the function.

Answer 2

In addition to what the other answers say, consider that in C and C++ all variables with static storage (e.g. mylock in your first example) are initialized to zero.
Simplifying, pthread_rwlock_t is a struct.
In your first example, mylock has static storage duration, so all of its internal members were initialized to zero. By chance, this equivalent to the "unlocked" state of pthread_rwlock_t, as the macro PTHREAD_RWLOCK_INITIALIZER mentioned in another answer initializes exactly everything to zero; in nptl/sysdeps/pthread/pthread.h you can find:
#define PTHREAD_RWLOCK_INITIALIZER \
{ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
Therefore all runs of your first example will always exhibit the same behavior (i.e. the lock will start unlocked).
In your second example, mylock is not initialized, because it has automatic storage duration. The behavior will then be dependent on what other values happen to be lying the that uninitialized area of memory. Most of the times, the lock with start in "locked" state, but, if you're lucky (on unlucky) enough, it will instead start unlocked.

Answer 3

The reason is quite clear, you even say so yourself... In the working version the variable is global, while in the non-working the variable is local.
A local variable is only known inside the function, during that call. So if a function is called twice then the variable is unique on both these calls.
If you want to use a local variable, you can mark it static, as that makes it "static" between all invocations of the function.
I suggest you read more about variable scoping and lifetime.