Error RWLockPosix::write_try_lock() { if (pthread_rwlock_trywrlock(&rwlock) != 0) { return ERR_BUSY; } else { return OK; } }
bool TRI_TryWriteLockReadWriteLock (TRI_read_write_lock_t* lock) { int rc; rc = pthread_rwlock_trywrlock(lock); return (rc == 0); }
int PlatformRWTryWLock(RWLock lock) { #ifndef WIN32 pthread_rwlock_t *l = lock; return pthread_rwlock_trywrlock(l); #else #endif }
int main(int argc, char** argv) { int r; pthread_mutex_t mutex; pthread_rwlock_t rwlock; struct timespec abs_timeout; time(&abs_timeout.tv_sec); abs_timeout.tv_nsec = 0; abs_timeout.tv_sec += 10; r = pthread_rwlock_init(&rwlock, NULL); assert(r == 0); fprintf(stderr, "Locking rwlock via pthread_rwlock_wrlock().\n"); r = pthread_rwlock_wrlock(&rwlock); assert(r == 0); r = pthread_rwlock_unlock(&rwlock); assert(r == 0); fprintf(stderr, "Locking rwlock via pthread_rwlock_trywrlock().\n"); r = pthread_rwlock_trywrlock(&rwlock); assert(r == 0); r = pthread_rwlock_unlock(&rwlock); assert(r == 0); fprintf(stderr, "Locking rwlock via pthread_rwlock_timedwrlock().\n"); #ifdef HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK r = pthread_rwlock_timedwrlock(&rwlock, &abs_timeout); assert(r == 0); r = pthread_rwlock_unlock(&rwlock); assert(r == 0); #endif fprintf(stderr, "Locking rwlock via pthread_rwlock_rdlock().\n"); r = pthread_rwlock_rdlock(&rwlock); assert(r == 0); r = pthread_rwlock_rdlock(&rwlock); assert(r == 0); r = pthread_rwlock_rdlock(&rwlock); assert(r == 0); r = pthread_rwlock_unlock(&rwlock); assert(r == 0); r = pthread_rwlock_unlock(&rwlock); assert(r == 0); r = pthread_rwlock_unlock(&rwlock); assert(r == 0); fprintf(stderr, "Locking rwlock via pthread_rwlock_tryrdlock().\n"); r = pthread_rwlock_tryrdlock(&rwlock); assert(r == 0); r = pthread_rwlock_unlock(&rwlock); assert(r == 0); fprintf(stderr, "Locking rwlock via pthread_rwlock_timedrdlock().\n"); #ifdef HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK r = pthread_rwlock_timedrdlock(&rwlock, &abs_timeout); assert(r == 0); r = pthread_rwlock_unlock(&rwlock); assert(r == 0); #endif fprintf(stderr, "Attempt to lock for writing recursively (not allowed).\n"); r = pthread_rwlock_wrlock(&rwlock); assert(r == 0); r = pthread_rwlock_wrlock(&rwlock); assert(r != 0); r = pthread_rwlock_unlock(&rwlock); assert(r == 0); r = pthread_rwlock_destroy(&rwlock); assert(r == 0); r = pthread_mutex_init(&mutex, NULL); assert(r == 0); fprintf(stderr, "Locking mutex via pthread_mutex_trylock().\n"); r = pthread_mutex_trylock(&mutex); assert(r == 0); r = pthread_mutex_unlock(&mutex); assert(r == 0); fprintf(stderr, "Locking mutex via pthread_mutex_lock().\n"); r = pthread_mutex_lock(&mutex); assert(r == 0); r = pthread_mutex_unlock(&mutex); assert(r == 0); fprintf(stderr, "Locking mutex via pthread_mutex_timedlock().\n"); #ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK r = pthread_mutex_timedlock(&mutex, &abs_timeout); assert(r == 0); r = pthread_mutex_unlock(&mutex); assert(r == 0); #endif r = pthread_mutex_destroy(&mutex); assert(r == 0); return 0; }
bool RWLock::try_write_lock() { IMPL(impl); if (pthread_rwlock_trywrlock(&impl->rwlock) == 0) return true; return false; }
bool cThreadLockRw::TryWriteLock() { int rv = pthread_rwlock_trywrlock( &m_rwlock ); return rv == 0; }
static void *trywrlock(void *arg) { int r = pthread_rwlock_trywrlock(arg); if (r != EBUSY) t_error("trywrlock for rdlocked lock returned %s, want EBUSY\n", strerror(r)); return 0; }
wi_boolean_t wi_rwlock_trywrlock(wi_rwlock_t *lock) { #ifdef WI_PTHREADS return (pthread_rwlock_trywrlock(&lock->rwlock) == 0); #else return true; #endif }
TEST(pthread, pthread_rwlock_smoke) { pthread_rwlock_t l; ASSERT_EQ(0, pthread_rwlock_init(&l, NULL)); // Single read lock ASSERT_EQ(0, pthread_rwlock_rdlock(&l)); ASSERT_EQ(0, pthread_rwlock_unlock(&l)); // Multiple read lock ASSERT_EQ(0, pthread_rwlock_rdlock(&l)); ASSERT_EQ(0, pthread_rwlock_rdlock(&l)); ASSERT_EQ(0, pthread_rwlock_unlock(&l)); ASSERT_EQ(0, pthread_rwlock_unlock(&l)); // Write lock ASSERT_EQ(0, pthread_rwlock_wrlock(&l)); ASSERT_EQ(0, pthread_rwlock_unlock(&l)); // Try writer lock ASSERT_EQ(0, pthread_rwlock_trywrlock(&l)); ASSERT_EQ(EBUSY, pthread_rwlock_trywrlock(&l)); ASSERT_EQ(EBUSY, pthread_rwlock_tryrdlock(&l)); ASSERT_EQ(0, pthread_rwlock_unlock(&l)); // Try reader lock ASSERT_EQ(0, pthread_rwlock_tryrdlock(&l)); ASSERT_EQ(0, pthread_rwlock_tryrdlock(&l)); ASSERT_EQ(EBUSY, pthread_rwlock_trywrlock(&l)); ASSERT_EQ(0, pthread_rwlock_unlock(&l)); ASSERT_EQ(0, pthread_rwlock_unlock(&l)); // Try writer lock after unlock ASSERT_EQ(0, pthread_rwlock_wrlock(&l)); ASSERT_EQ(0, pthread_rwlock_unlock(&l)); // EDEADLK in "read after write" ASSERT_EQ(0, pthread_rwlock_wrlock(&l)); ASSERT_EQ(EDEADLK, pthread_rwlock_rdlock(&l)); ASSERT_EQ(0, pthread_rwlock_unlock(&l)); // EDEADLK in "write after write" ASSERT_EQ(0, pthread_rwlock_wrlock(&l)); ASSERT_EQ(EDEADLK, pthread_rwlock_wrlock(&l)); ASSERT_EQ(0, pthread_rwlock_unlock(&l)); ASSERT_EQ(0, pthread_rwlock_destroy(&l)); }
// WriteLock with absolute timeout bool RWLockImplPosix::writeLock(const ::icl_core::TimeStamp& timeout) { #ifdef _SYSTEM_DARWIN_ int ret = pthread_rwlock_trywrlock(m_rwlock); while ((ret != 0) && ((timeout > icl_core::TimeStamp::now()))) { // one microsecond icl_core::os::usleep(1); ret = pthread_rwlock_trywrlock(m_rwlock); } return (ret == 0); #else struct timespec timeout_timespec = timeout.timespec(); bool ret = pthread_rwlock_timedwrlock(m_rwlock, &timeout_timespec); return (ret == 0); #endif }
DLL_EXPORT int ptt_pthread_rwlock_trywrlock(RWLOCK *rwlock, char *loc) { int result; PTTRACE ("trywr before", rwlock, NULL, loc, PTT_MAGIC); result = pthread_rwlock_trywrlock(rwlock); PTTRACE ("trywr after", rwlock, NULL, loc, result); return result; }
/// <summary> /// Tries to acquire write lock (now). Returns true if succeeded, false if failed. /// </summary> /// <returns></returns> bool RWLock::TryLockWrite() { #ifdef PLATFORM_WIN return (TryAcquireSRWLockExclusive( &mRwlock ) > 0); #else return (pthread_rwlock_trywrlock( &mRwlock ) == 0); #endif }
void * func(void * arg) { assert(pthread_rwlock_trywrlock(&rwlock1) == EBUSY); washere = 1; return 0; }
try_write_locker(pthread_rwlock_t &lock) : L(lock), ok(false) { int rv = pthread_rwlock_trywrlock(&L); if(rv != 0 && rv != EBUSY) throw strerror_exception("Failed trying wrlock", rv); ok = (rv == 0); }
int __ast_rwlock_trywrlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name) { int res; #ifdef DEBUG_THREADS struct ast_lock_track *lt = NULL; #ifdef HAVE_BKTR struct ast_bt *bt = NULL; #endif if (t->tracking) { lt = ast_get_reentrancy(&t->track); } if (lt) { #ifdef HAVE_BKTR struct ast_bt tmp; /* The implementation of backtrace() may have its own locks. * Capture the backtrace outside of the reentrancy lock to * avoid deadlocks. See ASTERISK-22455. */ ast_bt_get_addresses(&tmp); ast_reentrancy_lock(lt); if (lt->reentrancy < AST_MAX_REENTRANCY) { lt->backtrace[lt->reentrancy] = tmp; bt = <->backtrace[lt->reentrancy]; } ast_reentrancy_unlock(lt); ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt); #else ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t); #endif } #endif /* DEBUG_THREADS */ res = pthread_rwlock_trywrlock(&t->lock); #ifdef DEBUG_THREADS if (!res && lt) { ast_reentrancy_lock(lt); if (lt->reentrancy < AST_MAX_REENTRANCY) { lt->file[lt->reentrancy] = filename; lt->lineno[lt->reentrancy] = line; lt->func[lt->reentrancy] = func; lt->thread[lt->reentrancy] = pthread_self(); lt->reentrancy++; } ast_reentrancy_unlock(lt); ast_mark_lock_acquired(t); } else if (lt) { ast_mark_lock_failed(t); } #endif /* DEBUG_THREADS */ return res; }
int uv_rwlock_trywrlock(uv_rwlock_t* rwlock) { int err; err = pthread_rwlock_trywrlock(rwlock); if (err && err != EBUSY && err != EAGAIN) abort(); return -err; }
bool BufferFrame::tryLock(bool exclusive) { int result; if (exclusive){ result = pthread_rwlock_trywrlock(&header.rwlock); }else{ result = pthread_rwlock_tryrdlock(&header.rwlock); } return result == 0; }
bool TryLock(void) const { int ret = pthread_rwlock_trywrlock(&rwlock); DKASSERT_DESC_DEBUG(ret != EDEADLK, "The calling thread already owns the read/write lock."); DKASSERT_DESC_DEBUG(ret != EINVAL, "The value specified by rwlock is invalid."); DKASSERT_DESC_DEBUG(ret != ENOMEM, "Insufficient memory?"); return ret == 0; }
void kl_pthread_rwlock_wrlock(void *data, bool tryOnly) { if (tryOnly) { pthread_rwlock_trywrlock((pthread_rwlock_t *)data); } else { pthread_rwlock_wrlock((pthread_rwlock_t *)data); } }
/****************************************************************************** 函数名 :TryWriteLock 功能 :尝试对系统读写锁进行写加锁 输入 :无 输出 :无 返回值 :成功返回1,失败0 其他 :无 ******************************************************************************/ int CRWLock::TryWriteLock() { if (0 == pthread_rwlock_trywrlock(&m_rwlock)) { return 1; } return 0; }
int ldap_pvt_thread_rdwr_wtrylock( ldap_pvt_thread_rdwr_t *rw ) { int rc; LDAP_JITTER(25); rc = ERRVAL( pthread_rwlock_trywrlock( rw ) ); LDAP_ENSURE(rc == 0 || rc == EBUSY); LDAP_JITTER(25); return rc; }
static int lock_rwlock_trywrlock(lock_t * lock) { if(NULL == lock) { dbg_printf("check the param\n"); return(-1); } return pthread_rwlock_trywrlock(&lock->object.rwlock); }
bool RWMutex::TryLockWrite() { #if defined(__WIN32__) || defined(WIN32) //return TryEnterCriticalSection(&handle)!=0; return false; #elif defined(ILLUMINATION_THREAD_PTHREAD) return pthread_rwlock_trywrlock(&handle)==0; #endif }
bool ReadWriteMutexImpl::tryWriteLock() { int rc = pthread_rwlock_trywrlock(&_rwl); if( rc != 0 && rc != EBUSY) throw SystemError("pthread_rwlock_trywrlock failed"); return rc != EBUSY; }
bool rwlock_trywritelock(rwlock_t *rwlock) { const int err = pthread_rwlock_trywrlock(rwlock); if (err == 0) return true; else if (err == EBUSY) return false; else { error("rwlock error: %s", errno_error(err)); return false; } }
int32_t el_rwlock_trywrlock(el_rwlock_t* rwlock) { int ret = pthread_rwlock_trywrlock(rwlock); if (0 != ret && EBUSY != ret && EAGAIN != ret) abort(); return (0 == ret ? EL_OK : EL_NO); }
int Pthread_rwlock_trywrlock(pthread_rwlock_t *rw) { int n; if ( (n = pthread_rwlock_trywrlock(rw)) != 0) { errno = n; err_sys("pthread_rwlock_trywrlock error"); } return(n); }
ce_int_t ce_thread_rwlock_trywrlock(ce_thread_rwlock_t *rwlock) { ce_int_t st; st = pthread_rwlock_trywrlock(&rwlock->rwlock); /* Normalize the return code. */ if (st == EBUSY) st = CE_EBUSY; return st; }
int _wr_trylock(rwlock_t *lock, __maybe_unused const char *file, __maybe_unused const char *func, __maybe_unused const int line) { int ret = pthread_rwlock_trywrlock(&lock->rwlock); if (!ret) { lock->file = file; lock->func = func; lock->line = line; } return ret; }
static void worker1(pthread_rwlock_t* lk, AtomicUInt32* x) { x->fetchAndAdd(1); // 1 cout << "lock b try" << endl; while (1) { if (pthread_rwlock_trywrlock(lk) == 0) break; sleepmillis(10); } cout << "lock b got" << endl; x->fetchAndAdd(1); // 2 pthread_rwlock_unlock(lk); }