#include <pthread.h> #include <time.h> int pthread_rwlock_timedrdlock_np(pthread_rwlock_t *rwlock, const struct timespec *deltatime);Service Program Name: QP0WPTHR
The pthread_rwlock_timedrdlock_np() function attempts to acquire a shared read lock on the read/write lock specified by rwlock. If the shared read lock cannot be acquired in the deltatime specific, pthread_rwlock_timedrdlock_np() returns the EBUSY error.
Any number of threads can hold shared read locks on the same read/write lock object. If any thread holds an exclusive write lock on a read/write lock object, no other threads are allowed to hold a shared read or exclusive write lock.
If no threads are holding an exclusive write lock on the read/write lock, the calling thread successfully acquires the shared read lock.
If the calling thread already holds a shared read lock on the read/write lock, another read lock can be successfully acquired by the calling thread. If more than one shared read lock is successfully acquired by a thread on a read/write lock object, that thread is required to successfully call pthread_rwlock_unlock() a matching number of times.
With a large number of readers and relatively few writers, there is the possibility of writer starvation. If threads are waiting for an exclusive write lock on the read/write lock and there are threads that currently hold a shared read lock, the shared read lock request is granted.
If the read/write lock is destroyed while pthread_rwlock_timedrdlock_np() is waiting for the shared read lock, the EDESTROYED error is returned.
If a signal is delivered to the thread while it is waiting for the lock, the signal handler (if any) runs, and the thread resumes waiting. For a timed wait, when the thread resumes waiting after the signal handler runs, the wait time is reset. For example, suppose a thread specifies that it should wait for a lock for 5 seconds, and a signal handler runs in that thread after 2.5 seconds. After returning from the signal handler, the thread will resume its wait for another 5 seconds. The resulting wait is longer than the specified 5 seconds.
If a thread ends while holding a write lock, the attempt by another thread to acquire a shared read or exclusive write lock will not succeed. In this case, the attempt to acquire the lock will return the EBUSY error after the specified time elapses for the lock operation. If a thread ends while holding a read lock, the system automatically releases the read lock.
For the pthread_rwlock_timedrdlock_np() function, the pthreads run-time simulates the deadlock that has occurred in your application. When you are attempting to debug these deadlock scenarios, the CL command WRKJOB, option 20, shows the thread as in a condition wait. Displaying the call stack shows that the function timedDeadlockOnOrphanedRWLock is in the call stack.
If the calling thread currently holds an exclusive write lock on the read/write lock object, the shared read lock request is granted. After the shared read lock request is granted, the calling thread holds both the shared read and the exclusive write lock for the specified read/write lock object. If the thread calls pthread_rwlock_unlock() while holding one or more shared read locks and one or more exclusive write locks, the exclusive write locks are unlocked first. If more than one outstanding exclusive write lock was held by the thread, a matching number of successful calls to pthread_rwlock_unlock() must be done before all write locks are unlocked. At that time, subsequent calls to pthread_rwlock_unlock() will unlock the shared read locks.
You can use this behavior to allow your application to upgrade or downgrade one lock type to another. See Read/write locks can be upgraded/downgraded.
None.
If pthread_rwlock_timedrdlock_np() was not successful, the error condition returned usually indicates one of the following errors. Under some conditions, the value returned could indicate an error other than those listed here.
The value specified for the argument is not correct.
The lock could not be acquired in the time specified.
The lock was destroyed while waiting.
See Code disclaimer information for information pertaining to code examples.
#define _MULTI_THREADED
#include <pthread.h>
#include <stdio.h>
#include "check.h"
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
void *rdlockThread(void *arg)
{
int rc;
int count=0;
struct timespec ts;
/* 1.5 seconds */
ts.tv_sec = 1;
ts.tv_nsec = 500000000;
printf("Entered thread, getting read lock with timeout\n");
Retry:
rc = pthread_rwlock_timedrdlock_np(&rwlock, &ts);
if (rc == EBUSY) {
if (count >= 10) {
printf("Retried too many times, failure!\n");
exit(EXIT_FAILURE);
}
++count;
printf("RETRY...\n");
goto Retry;
}
checkResults("pthread_rwlock_rdlock() 1\n", rc);
sleep(2);
printf("unlock the read lock\n");
rc = pthread_rwlock_unlock(&rwlock);
checkResults("pthread_rwlock_unlock()\n", rc);
printf("Secondary thread complete\n");
return NULL;
}
int main(int argc, char **argv)
{
int rc=0;
pthread_t thread;
printf("Enter Testcase - %s\n", argv[0]);
printf("Main, get the write lock\n");
rc = pthread_rwlock_wrlock(&rwlock);
checkResults("pthread_rwlock_wrlock()\n", rc);
printf("Main, create the timed rd lock thread\n");
rc = pthread_create(&thread, NULL, rdlockThread, NULL);
checkResults("pthread_create\n", rc);
printf("Main, wait a bit holding the write lock\n");
sleep(5);
printf("Main, Now unlock the write lock\n");
rc = pthread_rwlock_unlock(&rwlock);
checkResults("pthread_rwlock_unlock()\n", rc);
printf("Main, wait for the thread to end\n");
rc = pthread_join(thread, NULL);
checkResults("pthread_join\n", rc);
rc = pthread_rwlock_destroy(&rwlock);
checkResults("pthread_rwlock_destroy()\n", rc);
printf("Main completed\n");
return 0;
}
Output:
Enter Testcase - QP0WTEST/TPRWLRD0 Main, get the write lock Main, create the timed rd lock thread Main, wait a bit Entered thread, getting read lock with timeout RETRY... RETRY... RETRY... Main, Now unlock the write lock Main, wait for the thread to end unlock the read lock Secondary thread complete Main completed
| Top | Pthread APIs | APIs by category |