#include <pthread.h> int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);Service Program Name: QP0WPTHR
The pthread_rwlock_trywrlock() function attempts to acquire an exclusive write lock on the read/write lock specified by rwlock. If the exclusive write lock cannot be immediately acquired, pthread_rwlock_timedwrlock_np() returns the EBUSY error.
Only one thread can hold an exclusive write lock on a read/write lock object. If any thread holds an exclusive write lock on a read/write lock object, no other threads will be allowed to hold a shared read or exclusive write lock.
If there are no threads holding an exclusive write lock or shared read lock on the read/write lock, the calling thread will successfully acquire the exclusive write lock.
If the calling thread already holds an exclusive write lock on the read/write lock, another write lock can be successfully acquired by the calling thread. If more than one exclusive write 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 there are threads waiting for an exclusive write lock on the read/write lock and there are threads that currently hold a shared read lock, the subsequent attempts to acquire a shared read lock request will be granted, while attempts to acquire the exclusive write lock will return the EBUSY error.
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 be successful. In this case, the attempt to acquire the lock will return the EBUSY error. If a thread ends while holding a read lock, the system automatically releases the read lock.
If the calling thread currently holds a shared read lock on the read/write lock object and there are no other threads holding a shared read lock, the exclusive write request will be granted. After the exclusive write 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.
This behavior can be used 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_trywrlock() 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 timed specified.
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 *wrlockThread(void *arg)
{
int rc;
int count=0;
printf("%.8x %.8x: Entered thread, getting write lock with timeout\n",
pthread_getthreadid_np());
Retry:
rc = pthread_rwlock_trywrlock(&rwlock);
if (rc == EBUSY) {
if (count >= 10) {
printf("%.8x %.8x: Retried too many times, failure!\n",
pthread_getthreadid_np());
exit(EXIT_FAILURE);
}
++count;
printf("%.8x %.8x: Go off an do other work, then RETRY...\n",
pthread_getthreadid_np());
sleep(1);
goto Retry;
}
checkResults("pthread_rwlock_trywrlock() 1\n", rc);
printf("%.8x %.8x: Got the write lock\n", pthread_getthreadid_np());
sleep(2);
printf("%.8x %.8x: Unlock the write lock\n",
pthread_getthreadid_np());
rc = pthread_rwlock_unlock(&rwlock);
checkResults("pthread_rwlock_unlock()\n", rc);
printf("%.8x %.8x: Secondary thread complete\n",
pthread_getthreadid_np());
return NULL;
}
int main(int argc, char **argv)
{
int rc=0;
pthread_t thread, thread2;
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 write lock threads\n");
rc = pthread_create(&thread, NULL, wrlockThread, NULL);
checkResults("pthread_create\n", rc);
rc = pthread_create(&thread2, NULL, wrlockThread, NULL);
checkResults("pthread_create\n", rc);
printf("Main, wait a bit holding this write lock\n");
sleep(1);
printf("Main, Now unlock the write lock\n");
rc = pthread_rwlock_unlock(&rwlock);
checkResults("pthread_rwlock_unlock()\n", rc);
printf("Main, wait for the threads to end\n");
rc = pthread_join(thread, NULL);
checkResults("pthread_join\n", rc);
rc = pthread_join(thread2, 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/TPRWLWR1 Main, get the write lock Main, create the timed write lock threads 00000000 0000000d: Entered thread, getting write lock with timeout 00000000 0000000d: Go off an do other work, then RETRY... Main, wait a bit holding this write lock 00000000 0000000e: Entered thread, getting write lock with timeout 00000000 0000000e: Go off an do other work, then RETRY... 00000000 0000000d: Go off an do other work, then RETRY... Main, Now unlock the write lock Main, wait for the threads to end 00000000 0000000e: Got the write lock 00000000 0000000d: Go off an do other work, then RETRY... 00000000 0000000e: Unlock the write lock 00000000 0000000e: Secondary thread complete 00000000 0000000d: Got the write lock 00000000 0000000d: Unlock the write lock 00000000 0000000d: Secondary thread complete Main completed
| Top | Pthread APIs | APIs by category |