/** * @brief Initialize a pthread read/write lock attributes object with default values. * @see pthread_rwlockattr_init() * @param attr a pointer to the read/write lock attributes object to be initialized. * @return 0 on success or an error number on failure. */ int rwlock_attr_init(pthread_rwlockattr_t *attr) { #ifdef MAGMA_PEDANTIC int result = pthread_rwlockattr_init(attr); if (result) log_pedantic("Could not initialize the read/write lock attribute object. {pthread_rwlockattr_init = %i}", result); return result; #else return pthread_rwlockattr_init(attr); #endif }
/** \brief Initialize the rwlock taking the rwlock attributes into account * * \b os_rwlockInit calls \b pthread_rwlock_init to intialize the posix * \b rwlock. * * In case the scope attribute is \b OS_SCOPE_SHARED, the posix * \b rwlock "pshared" attribute is set to \b PTHREAD_PROCESS_SHARED * otherwise it is set to \b PTHREAD_PROCESS_PRIVATE. */ os_result os_rwlockInit ( os_rwlock *rwlock, const os_rwlockAttr *rwlockAttr) { pthread_rwlockattr_t rwattr; int result; os_result rv; assert (rwlock != NULL); assert (rwlockAttr != NULL); pthread_rwlockattr_init (&rwattr); if (rwlockAttr->scopeAttr == OS_SCOPE_SHARED) { result = pthread_rwlockattr_setpshared (&rwattr, PTHREAD_PROCESS_SHARED); } else { result = pthread_rwlockattr_setpshared (&rwattr, PTHREAD_PROCESS_PRIVATE); } if (result == 0) { pthread_rwlock_init (rwlock, &rwattr); } pthread_rwlockattr_destroy (&rwattr); if (result == 0) { rv = os_resultSuccess; } else { rv = os_resultFail; } return rv; }
/* The 'offset' parameter is optional, but must be provided to be able to use heap_remove(). * If heap_remove() will not be used, then a negative value can be provided. */ heap_t heap_new(int height, ssize_t offset, int cmp(const void *x, const void *y)) { heap_t heap; pthread_mutexattr_t attr; pthread_rwlockattr_t rwattr; if (height <= 0) height = 8; if (cmp == NULL) return NULL; if (NEW(heap) == NULL) return NULL; heap->avail = (height << 1) - 1; heap->curr = 0; if ((heap->h = CALLOC(1, heap->avail * sizeof *heap->h)) == NULL) { FREE(heap); return NULL; } heap->offset = offset; heap->cmp = cmp; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP); pthread_mutex_init(&heap->lock, &attr); pthread_mutexattr_destroy(&attr); pthread_rwlockattr_init(&rwattr); pthread_rwlockattr_setkind_np(&rwattr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP); pthread_rwlock_init(&heap->rwlock, &rwattr); pthread_rwlockattr_destroy(&rwattr); return heap; }
vp_lock_t *vp_lock_new(pthread_mutexattr_t *ma, pthread_condattr_t *ca) { vp_lock_t *l; #ifdef HAVE_PTHREAD_RWLOCKS pthread_rwlockattr_t attr; #endif l = calloc(1,sizeof(*l)); AN(l); l->magic = VP_LOCK_MAGIC; #ifndef HAVE_PTHREAD_RWLOCKS l->r = l->w = l->nw = 0; l->t = vp_lock_unset; AZ(pthread_mutex_init(&l->m,ma)); AZ(pthread_cond_init(&l->c,ca)); #else AZ(pthread_rwlockattr_init(&attr)); #ifdef HAVE_PTHREAD_RWLOCKATTR_SETPSHARED AZ(pthread_rwlockattr_setpshared(&attr,PTHREAD_PROCESS_PRIVATE)); #endif AZ(pthread_rwlock_init(&l->l,&attr)); AZ(pthread_rwlockattr_destroy(&attr)); #endif return l; }
celix_status_t producer_create(char* name, producer_pt* producer) { celix_status_t status = CELIX_SUCCESS; producer_pt lclProducer = calloc(1, sizeof(*lclProducer)); if (lclProducer != NULL) { lclProducer->name = strdup(name); lclProducer->utilizationStatsName = calloc(1, strlen(name) + strlen(THROUGHPUT_NAME_POSTFIX) + 1); if (lclProducer->name != NULL && lclProducer->utilizationStatsName != NULL) { pthread_rwlockattr_t queueLockAttr; sprintf(lclProducer->utilizationStatsName, "%s%s", lclProducer->name, (char*) THROUGHPUT_NAME_POSTFIX); pthread_rwlockattr_init(&queueLockAttr); pthread_rwlockattr_setkind_np(&queueLockAttr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP); pthread_rwlock_init(&lclProducer->queueLock, &queueLockAttr); lclProducer->queueServices = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL); (*producer) = lclProducer; } else { status = CELIX_ENOMEM; } } else { status = CELIX_ENOMEM; } return status; }
static uint32_t diameter_create_lock(diameter_lock_handle *lock) { pthread_rwlockattr_t rwlock_attr; pthread_rwlock_t *rwlock; int ret; ret = pthread_rwlockattr_init(&rwlock_attr); if (ret) return DIAMETER_CB_ERROR; ret = pthread_rwlockattr_setkind_np(&rwlock_attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP); if (ret) return DIAMETER_CB_ERROR; rwlock = nkn_malloc_type(sizeof(pthread_rwlock_t), mod_diameter_t); if (rwlock == NULL) return DIAMETER_CB_ERROR; ret = pthread_rwlock_init(rwlock, &rwlock_attr); if (ret) { free(rwlock); return DIAMETER_CB_ERROR; } *lock = rwlock; return DIAMETER_CB_OK; }
int main() { pthread_rwlockattr_t rwla; int pshared; int rc = 0; #ifndef PTHREAD_PROCESS_SHARED printf("process-shared attribute is not available for testing\n"); return PTS_UNSUPPORTED; #endif /* Initialize a rwlock attributes object */ if (pthread_rwlockattr_init(&rwla) != 0) { printf("Error at pthread_rwlockattr_init()\n"); return PTS_UNRESOLVED; } /* The default 'pshared' attribute should be PTHREAD_PROCESS_PRIVATE */ rc = pthread_rwlockattr_getpshared(&rwla, &pshared); if (rc != 0) { printf("Test FAILED: Error at pthread_rwlockattr_getpshared(): %d\n", rc); return PTS_FAIL; } if (pshared != PTHREAD_PROCESS_PRIVATE) { printf("Test FAILED: Incorrect default pshared value: %d\n", pshared); return PTS_FAIL; } printf("Test PASSED\n"); return PTS_PASS; }
int main(void) { pthread_rwlockattr_t rwla; int rc; /* Initialize a rwlock attributes object */ rc = pthread_rwlockattr_init(&rwla); if (rc != 0) { printf("Error at pthread_rwlockattr_init(), error code: %d\n", rc); return PTS_UNRESOLVED; } /* Destroy the rwlock attributes object */ rc = pthread_rwlockattr_destroy(&rwla); if (rc != 0) { printf ("Error at pthread_rwlockattr_destroy(), error code: %d\n", rc); printf("Test FAILED\n"); return PTS_FAIL; } printf("Test PASSED\n"); return PTS_PASS; }
void rw_init_flags(struct rwlock *rw, const char *name, int opts) { pthread_rwlockattr_t attr; int flags; MPASS((opts & ~(RW_DUPOK | RW_NOPROFILE | RW_NOWITNESS | RW_QUIET | RW_RECURSE)) == 0); ASSERT_ATOMIC_LOAD_PTR(rw->rw_lock, ("%s: rw_lock not aligned for %s: %p", __func__, name, &rw->rw_lock)); flags = LO_UPGRADABLE; if (opts & RW_DUPOK) flags |= LO_DUPOK; if (opts & RW_NOPROFILE) flags |= LO_NOPROFILE; if (!(opts & RW_NOWITNESS)) flags |= LO_WITNESS; if (opts & RW_RECURSE) flags |= LO_RECURSABLE; if (opts & RW_QUIET) flags |= LO_QUIET; lock_init(&rw->lock_object, &lock_class_rw, name, NULL, flags); pthread_rwlockattr_init(&attr); pthread_rwlock_init(&rw->rw_lock, &attr); }
int __ast_rwlock_init(int tracking, const char *filename, int lineno, const char *func, const char *rwlock_name, ast_rwlock_t *t) { int res; pthread_rwlockattr_t attr; #ifdef DEBUG_THREADS #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE) int canlog = strcmp(filename, "logger.c") & t->tracking; if (t->lock != ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) { __ast_mutex_logger("%s line %d (%s): Warning: rwlock '%s' is already initialized.\n", filename, lineno, func, rwlock_name); return 0; } #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */ if ((t->tracking = tracking)) { ast_reentrancy_init(&t->track); } #endif /* DEBUG_THREADS */ pthread_rwlockattr_init(&attr); #ifdef HAVE_PTHREAD_RWLOCK_PREFER_WRITER_NP pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NP); #endif res = pthread_rwlock_init(&t->lock, &attr); pthread_rwlockattr_destroy(&attr); return res; }
int main() { pthread_rwlockattr_t rwa; pthread_rwlock_t rwl1, rwl2; int rc; /* Initialize a read-write lock attributes object */ rc = pthread_rwlockattr_init(&rwa); if (rc != 0) { printf("Error at pthread_rwlockattr_init(), returns %d\n", rc); return PTS_UNRESOLVED; } if ((rc = pthread_rwlock_init(&rwl1, &rwa)) != 0) { printf("Error at 1st pthread_rwlock_init()\n"); return PTS_UNRESOLVED; } if ((rc = pthread_rwlock_init(&rwl2, &rwa)) != 0) { printf("Error at 2nd pthread_rwlock_init()\n"); return PTS_UNRESOLVED; } if ((rc = pthread_rwlock_rdlock(&rwl1)) != 0) { printf("Error at pthread_rwlock_rdlock(): rwl1\n"); return PTS_UNRESOLVED; } if ((rc = pthread_rwlockattr_destroy(&rwa)) != 0) { printf("Error at pthread_rwlockattr_destory()\n"); return PTS_UNRESOLVED; } if ((rc = pthread_rwlock_unlock(&rwl1)) != 0) { printf("Error at pthread_rwlock_unlock: rwl1\n"); printf("Test Failed.\n"); return PTS_FAIL; } if ((rc = pthread_rwlock_rdlock(&rwl2)) != 0) { printf("Error at pthread_rwlock_rdlock():rwl2\n"); printf("Test Failed.\n"); return PTS_FAIL; } if ((rc = pthread_rwlock_unlock(&rwl2)) != 0) { printf("Error at pthread_rwlock_unlock:rwl2\n"); printf("Test Failed.\n"); return PTS_FAIL; } printf("Test PASSED\n"); return PTS_PASS; }
cRwLock::cRwLock(bool PreferWriter) { pthread_rwlockattr_t attr; pthread_rwlockattr_init(&attr); pthread_rwlockattr_setkind_np(&attr, PreferWriter ? PTHREAD_RWLOCK_PREFER_WRITER_NP : PTHREAD_RWLOCK_PREFER_READER_NP); pthread_rwlock_init(&rwlock, &attr); }
static void noit_log_init_rwlock(noit_log_stream_t ls) { pthread_rwlockattr_t attr; pthread_rwlockattr_init(&attr); pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); pthread_rwlock_init(ls->lock, &attr); }
int get_thread_attr() { pthread_attr_t attr; pthread_attr_init(&attr); print_thread_attr(&attr); pthread_attr_destroy(&attr); printf("\n"); pthread_mutexattr_t mutex_attr; pthread_mutexattr_init(&mutex_attr); print_mutexattr(&mutex_attr); pthread_mutexattr_destroy(&mutex_attr); printf("\n"); pthread_rwlockattr_t rwlock_attr; pthread_rwlockattr_init(&rwlock_attr); print_rwlockattr(&rwlock_attr); pthread_rwlockattr_destroy(&rwlock_attr); printf("\n"); pthread_condattr_t cond_attr; pthread_condattr_init(&cond_attr); print_condattr(&cond_attr); pthread_condattr_destroy(&cond_attr); printf("\n"); return THREAD_ATTR_OK; }
struct uwsgi_lock_item *uwsgi_rwlock_fast_init(char *id) { #ifdef OBSOLETE_LINUX_KERNEL return uwsgi_lock_fast_init(id); #else pthread_rwlockattr_t attr; struct uwsgi_lock_item *uli = uwsgi_register_lock(id, 1); if (pthread_rwlockattr_init(&attr)) { uwsgi_log("unable to allocate rwlock structure\n"); exit(1); } if (pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED)) { uwsgi_log("unable to share rwlock\n"); exit(1); } if (pthread_rwlock_init((pthread_rwlock_t *) uli->lock_ptr, &attr)) { uwsgi_log("unable to initialize rwlock\n"); exit(1); } pthread_rwlockattr_destroy(&attr); uli->can_deadlock = 1; return uli; #endif }
CRWLock::CRWLock() { pthread_rwlockattr_t rwlock_attr; int res; if((res = pthread_rwlockattr_init(&rwlock_attr)) != 0) { printf("file: "__FILE__", line: %d, " \ "call pthread_rwlockattr_init failed, err: %s\n", \ __LINE__, strerror(res)); throw res; } if((res = pthread_rwlockattr_setpshared(&rwlock_attr, \ PTHREAD_PROCESS_SHARED)) != 0) { printf("file: "__FILE__", line: %d, " \ "set rwlock attr to PTHREAD_PROCESS_SHARED failed, err: %s\n", \ __LINE__, strerror(res)); throw res; } if((res = pthread_rwlock_init(&m_rwlock, &rwlock_attr)) != 0) { printf("file: "__FILE__", line: %d, " \ "call pthread_rwlock_init failed, err: %s\n", \ __LINE__, strerror(res)); throw res; } pthread_rwlockattr_destroy(&rwlock_attr); }
void test_rwlock_init(void) { int rc; pthread_rwlockattr_t attrs; rc = pthread_rwlockattr_init(&attrs); ASSERT_EQ(rc, 0); int shared = -1; rc = pthread_rwlockattr_getpshared(&attrs, &shared); ASSERT_EQ(rc, 0); ASSERT_EQ(shared, PTHREAD_PROCESS_PRIVATE); rc = pthread_rwlockattr_setpshared(&attrs, PTHREAD_PROCESS_SHARED); #ifndef __GLIBC__ /* * glibc's pthread_rwlockattr_setpshared doesn't currently fail * with PTHREAD_PROCESS_SHARED. TODO(sbc): remove this once * we fix the glibc bug: * https://code.google.com/p/nativeclient/issues/detail?id=4142 */ ASSERT_EQ(rc, EINVAL); #endif rc = pthread_rwlockattr_setpshared(&attrs, PTHREAD_PROCESS_PRIVATE); ASSERT_EQ(rc, 0); rc = pthread_rwlock_init(&g_rwlock, &attrs); ASSERT_EQ(rc, 0); rc = pthread_rwlockattr_destroy(&attrs); ASSERT_EQ(rc, 0); }
int main() { { pthread_mutexattr_t attr; if (pthread_mutexattr_init(&attr) != 0) { abort(); } if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL) != 0) { abort(); } if (pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_PRIVATE) != 0) { abort(); } } { pthread_rwlockattr_t attr; if (pthread_rwlockattr_init(&attr) != 0) { abort(); } if (pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_PRIVATE) != 0) { abort(); } } // TODO(hamaji): PTHREAD_MUTEX_INITIALIZER has a different implementation... #if 0 if (pthread_mutex_lock(&g_mutex) != 0) { abort(); } #endif }
/** * @brief Initialize the package. */ void cih_pkginit(void) { pthread_rwlockattr_t rwlock_attr; cih_partition_t *cp; uint32_t npart; uint32_t cache_sz = 32767; /* XXX */ int ix; /* avoid writer starvation */ pthread_rwlockattr_init(&rwlock_attr); #ifdef GLIBC pthread_rwlockattr_setkind_np( &rwlock_attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP); #endif npart = nfs_param.cache_param.nparts; cih_fhcache.npart = npart; cih_fhcache.partition = gsh_calloc(npart, sizeof(cih_partition_t)); for (ix = 0; ix < npart; ++ix) { cp = &cih_fhcache.partition[ix]; cp->part_ix = ix; pthread_rwlock_init(&cp->lock, &rwlock_attr); avltree_init(&cp->t, cih_fh_cmpf, 0 /* must be 0 */); cih_fhcache.cache_sz = cache_sz; cp->cache = gsh_calloc(cache_sz, sizeof(struct avltree_node *)); } initialized = true; }
int main() { int cnt = 0; pthread_rwlockattr_t rwlockattr; if(pthread_rwlockattr_init(&rwlockattr) != 0) { printf("Error at pthread_rwlockattr_init()\n"); return PTS_UNRESOLVED; } if(pthread_rwlock_init(&rwlock, &rwlockattr) != 0) { printf("Test FAILED: Error in pthread_rwlock_init()\n"); return PTS_FAIL; } while(cnt++ < COUNT) { if(pthread_rwlock_rdlock(&rwlock) != 0) { printf("Test FAILED: cannot get read lock on %dth loop\n", cnt); return PTS_FAIL; } if(pthread_rwlock_unlock(&rwlock) != 0) { printf("Test FAILED: cannot release read lock on %dth loop\n", cnt); return PTS_FAIL; } if(pthread_rwlock_wrlock(&rwlock) != 0) { printf("Test FAILED: cannot get write lock on %dth loop\n", cnt); return PTS_FAIL; } if(pthread_rwlock_unlock(&rwlock) != 0) { printf("Test FAILED: cannot release write lock on %dth loop\n", cnt); return PTS_FAIL; } } if(pthread_rwlock_destroy(&rwlock) != 0) { printf("Error at pthread_rwlockattr_destroy()\n"); return PTS_UNRESOLVED; } if(pthread_rwlockattr_destroy(&rwlockattr) != 0) { printf("Error at pthread_rwlockattr_destroy()\n"); return PTS_UNRESOLVED; } printf("Test PASSED\n"); return PTS_PASS; }
void InitTransactionLock(void) { pthread_rwlockattr_t attr; pthread_rwlockattr_init(&attr); pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); pthread_rwlock_init(&CommitProcArrayLock, &attr); pthread_rwlock_init(&ProcCommitLock, &attr); }
static pthread_rwlock_t* hybris_alloc_init_rwlock(void) { pthread_rwlock_t *realrwlock = malloc(sizeof(pthread_rwlock_t)); pthread_rwlockattr_t attr; pthread_rwlockattr_init(&attr); pthread_rwlock_init(realrwlock, &attr); return realrwlock; }
RWLock::RWLock(string name_): rwname(name_) { pthread_rwlockattr_t attr; pthread_rwlockattr_init(&attr); pthread_rwlock_init(&rwlock, &attr); pthread_rwlockattr_destroy(&attr); }
static int my_pthread_rwlockattr_init(pthread_rwlockattr_t *__attr) { pthread_rwlockattr_t *realattr; realattr = malloc(sizeof(pthread_rwlockattr_t)); *((unsigned int *)__attr) = (unsigned int) realattr; return pthread_rwlockattr_init(realattr); }
CRWMutex::CRWMutex() { #ifndef ANDROID pthread_rwlockattr_init(&mAttr); pthread_rwlock_init(&mMutex, &mAttr); #else rwlock_init(&mMutex); #endif //ANDROID }
CRWLock::CRWLock() { pthread_rwlockattr_t attr; pthread_rwlockattr_init( &attr ); //写锁优先,一旦有写锁去请求,后续所有的读锁请求都会阻塞,即使已经有线程获取了读锁也如此 pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP); pthread_rwlock_init(&_rwlock,&attr); pthread_rwlockattr_destroy(&attr); }
void *POSIX_Init( void *argument ) { int status; pthread_t threadId; benchmark_timer_t end_time; pthread_rwlockattr_t attr; TEST_BEGIN(); status = pthread_create( &threadId, NULL, Blocker, NULL ); rtems_test_assert( status == 0 ); /* * Deliberately create the rwlock after the threads. This way if the * threads do run before we intend, they will get an error. */ /* creating rwlock */ status = pthread_rwlockattr_init( &attr ); rtems_test_assert( status == 0 ); status = pthread_rwlock_init( &rwlock, &attr ); rtems_test_assert( status == 0 ); /* * Ensure the rwlock is unavailable so the other threads block. */ /* lock rwlock to ensure thread blocks */ status = pthread_rwlock_wrlock(&rwlock); rtems_test_assert( status == 0 ); /* * Let the other thread start so the thread startup overhead, * is accounted for. When we return, we can start the benchmark. */ sched_yield(); /* let other thread run */ benchmark_timer_initialize(); status = pthread_rwlock_unlock(&rwlock); /* unlock the rwlock */ end_time = benchmark_timer_read(); rtems_test_assert( status == 0 ); put_time( "pthread_rwlock_unlock: thread waiting no preempt", end_time, 1, 0, 0 ); TEST_END(); rtems_test_exit( 0 ); return NULL; }
ReadWriteLock::ReadWriteLock() { pthread_rwlockattr_t myAttributes; pthread_rwlockattr_init(&myAttributes); pthread_rwlockattr_setkind_np(&myAttributes,PTHREAD_RWLOCK_PREFER_READER_NP); int myStatus = pthread_rwlock_init(&_myLock,&myAttributes); if (myStatus != 0) { throw LockInitFailed(strerror(myStatus),PLUS_FILE_LINE); } }
guac_client* guac_client_alloc() { int i; pthread_rwlockattr_t lock_attributes; /* Allocate new client */ guac_client* client = malloc(sizeof(guac_client)); if (client == NULL) { guac_error = GUAC_STATUS_NO_MEMORY; guac_error_message = "Could not allocate memory for client"; return NULL; } /* Init new client */ memset(client, 0, sizeof(guac_client)); client->args = __GUAC_CLIENT_NO_ARGS; client->state = GUAC_CLIENT_RUNNING; client->last_sent_timestamp = guac_timestamp_current(); /* Generate ID */ client->connection_id = guac_generate_id(GUAC_CLIENT_ID_PREFIX); if (client->connection_id == NULL) { free(client); return NULL; } /* Allocate buffer and layer pools */ client->__buffer_pool = guac_pool_alloc(GUAC_BUFFER_POOL_INITIAL_SIZE); client->__layer_pool = guac_pool_alloc(GUAC_BUFFER_POOL_INITIAL_SIZE); /* Allocate stream pool */ client->__stream_pool = guac_pool_alloc(0); /* Initialize streams */ client->__output_streams = malloc(sizeof(guac_stream) * GUAC_CLIENT_MAX_STREAMS); for (i=0; i<GUAC_CLIENT_MAX_STREAMS; i++) { client->__output_streams[i].index = GUAC_CLIENT_CLOSED_STREAM_INDEX; } /* Init locks */ pthread_rwlockattr_init(&lock_attributes); pthread_rwlockattr_setpshared(&lock_attributes, PTHREAD_PROCESS_SHARED); pthread_rwlock_init(&(client->__users_lock), &lock_attributes); /* Set up socket to broadcast to all users */ client->socket = guac_socket_broadcast(client); return client; }
rw_mutex::impl::impl() :valid(false) { pthread_rwlockattr_t attr; pthread_rwlockattr_init(&attr); #ifdef PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP // switch to writer-preferred lock on linux pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP); #endif int res=pthread_rwlock_init(&lk,&attr); if (res==0) valid=true; }