BOOL CRWLockSlim::AcquireWriterLock( DWORD dwTimeout )
{
    BOOL bRet = FALSE;

#if ( _WIN32_WINNT_WIN7 <= _WIN32_WINNT )
    if ( INFINITE == dwTimeout || FALSE == m_bWin7AndLater )
    {
        AcquireSRWLockExclusive( &m_srwLock );
        bRet = TRUE;
    }
    else
    {
        LARGE_INTEGER lnCurr , lnEnd;
        QueryPerformanceCounter( &lnCurr );
        lnEnd.QuadPart = lnCurr.QuadPart + dwTimeout * ( m_lnFreq.QuadPart / 1000 );
        do
        {
            QueryPerformanceCounter( &lnCurr );
            bRet = (BOOL)TryAcquireSRWLockExclusive( &m_srwLock );
        } while ( lnCurr.QuadPart < lnEnd.QuadPart );
    }
#else
    AcquireSRWLockExclusive( &m_srwLock );
    bRet = TRUE;
#endif

    return bRet;
}

void TRI_LockMutex (TRI_mutex_t* mutex) {
  // as of VS2013, exclusive SRWLocks tend to be faster than native mutexes
#if TRI_WINDOWS_VISTA_LOCKS
  DWORD result = WaitForSingleObject(mutex->_mutex, INFINITE);

  switch (result) {
    case WAIT_ABANDONED: {
      LOG_FATAL_AND_EXIT("locks-win32.c:TRI_LockMutex:could not lock the condition --> WAIT_ABANDONED");
    }

    case WAIT_OBJECT_0: {
      // everything ok
      break;
    }

    case WAIT_TIMEOUT: {
      LOG_FATAL_AND_EXIT("locks-win32.c:TRI_LockMutex:could not lock the condition --> WAIT_TIMEOUT");
    }

    case WAIT_FAILED: {
      result = GetLastError();
      LOG_FATAL_AND_EXIT("locks-win32.c:TRI_LockMutex:could not lock the condition --> WAIT_FAILED - reason -->%d",result);
    }
  }
#else
  AcquireSRWLockExclusive(&mutex->_mutex);
#endif
}

static int cache_insert(
    struct idmap_cache *cache,
    const struct idmap_lookup *lookup,
    const struct list_entry *src)
{
    struct list_entry *entry;
    int status = NO_ERROR;

    AcquireSRWLockExclusive(&cache->lock);

    /* search for an existing match */
    entry = list_search(&cache->head, lookup->value, lookup->compare);
    if (entry) {
        /* overwrite the existing entry with the new results */
        cache->ops->entry_copy(entry, src);
        goto out;
    }

    /* initialize a new entry and add it to the list */
    entry = cache->ops->entry_alloc();
    if (entry == NULL) {
        status = GetLastError();
        goto out;
    }
    cache->ops->entry_copy(entry, src);
    list_add_head(&cache->head, entry);
out:
    ReleaseSRWLockExclusive(&cache->lock);
    return status;
}

void __MCF_CRT_TlsThreadCleanup(){
	ThreadMap *const pMap = TlsGetValue(g_dwTlsIndex);
	if(pMap){
		TlsObject *pObject = pMap->pLastByThread;
		while(pObject){
			TlsKey *const pKey = pObject->pKey;

			AcquireSRWLockExclusive(&(pKey->srwLock));
			{
				if(pKey->pLastByKey == pObject){
					pKey->pLastByKey = pObject->pPrevByKey;
				}
			}
			ReleaseSRWLockExclusive(&(pKey->srwLock));

			if(pKey->pfnCallback){
				(*pKey->pfnCallback)(pObject->nValue);
			}

			TlsObject *const pTemp = pObject->pPrevByThread;
			free(pObject);
			pObject = pTemp;
		}
		free(pMap);
		TlsSetValue(g_dwTlsIndex, nullptr);
	}

	__MCF_CRT_RunEmutlsDtors();
}

				_EXP_IMPL void __cdecl Event::set()
				{
					AcquireSRWLockExclusive(reinterpret_cast<PSRWLOCK>(&m_lock));
					m_isSet = true;
					WakeAllConditionVariable(reinterpret_cast<PCONDITION_VARIABLE>(&m_cond));
					ReleaseSRWLockExclusive(reinterpret_cast<PSRWLOCK>(&m_lock));
				}

static int virtualfs_text_llseek(struct file *f, loff_t offset, loff_t *newoffset, int whence)
{
	AcquireSRWLockExclusive(&f->rw_lock);
	struct virtualfs_text *file = (struct virtualfs_text *)f;
	loff_t target;
	int r;
	switch (whence)
	{
	case SEEK_SET: target = offset; break;
	case SEEK_CUR: target = file->position + offset; break;
	case SEEK_END: target = file->textlen - offset; break;
	default: r = -L_EINVAL; goto out;
	}
	if (target >= 0 && target < file->textlen)
	{
		file->position = (int)target;
		*newoffset = target;
		r = 0;
	}
	else
		r = -L_EINVAL;
out:
	ReleaseSRWLockExclusive(&f->rw_lock);
	return r;
}

BOOST_LOG_API bool once_block_sentry::enter_once_block() const
{
    AcquireSRWLockExclusive(&g_OnceBlockMutex);

    once_block_flag volatile& flag = m_Flag;
    while (flag.status != once_block_flag::initialized)
    {
        if (flag.status == once_block_flag::uninitialized)
        {
            flag.status = once_block_flag::being_initialized;
            ReleaseSRWLockExclusive(&g_OnceBlockMutex);

            // Invoke the initializer block
            return false;
        }
        else
        {
            while (flag.status == once_block_flag::being_initialized)
            {
                BOOST_VERIFY(SleepConditionVariableSRW(
                    &g_OnceBlockCond, &g_OnceBlockMutex, INFINITE, 0));
            }
        }
    }

    ReleaseSRWLockExclusive(&g_OnceBlockMutex);

    return true;
}

VOID
APPLICATION_INFO::ShutDownApplication()
{
    APPLICATION* pApplication = NULL;
    BOOL         fLockAcquired = FALSE;

    // pApplication can be NULL due to app_offline
    if (m_pApplication != NULL)
    {
        AcquireSRWLockExclusive(&m_srwLock);
        fLockAcquired = TRUE;
        if (m_pApplication != NULL)
        {
            pApplication = m_pApplication;

            // Set m_pApplication to NULL first to prevent anyone from using it
            m_pApplication = NULL;
            pApplication->ShutDown();
            pApplication->DereferenceApplication();
        }

        if (fLockAcquired)
        {
            ReleaseSRWLockExclusive(&m_srwLock);
        }
    }
}

static void server_addrs_add(
    IN OUT struct server_addrs *addrs,
    IN const netaddr4 *addr)
{
    /* we keep a list of addrs used to connect to each server. once it gets
     * bigger than NFS41_ADDRS_PER_SERVER, overwrite the oldest addrs. use
     * server_addrs.next_index to implement a circular array */

    AcquireSRWLockExclusive(&addrs->lock);

    if (multi_addr_find(&addrs->addrs, addr, NULL)) {
        dprintf(SRVLVL, "server_addrs_add() found existing addr '%s'.\n",
            addr->uaddr);
    } else {
        /* overwrite the address at 'next_index' */
        StringCchCopyA(addrs->addrs.arr[addrs->next_index].netid,
            NFS41_NETWORK_ID_LEN+1, addr->netid);
        StringCchCopyA(addrs->addrs.arr[addrs->next_index].uaddr,
            NFS41_UNIVERSAL_ADDR_LEN+1, addr->uaddr);

        /* increment/wrap next_index */
        addrs->next_index = (addrs->next_index + 1) % NFS41_ADDRS_PER_SERVER;
        /* update addrs.count if necessary */
        if (addrs->addrs.count < addrs->next_index)
            addrs->addrs.count = addrs->next_index;

        dprintf(SRVLVL, "server_addrs_add() added new addr '%s'.\n",
            addr->uaddr);
    }
    ReleaseSRWLockExclusive(&addrs->lock);
}

static int open_unlock_delegate(
    IN nfs41_open_state *open,
    IN const nfs41_lock_state *input)
{
    struct list_entry *entry;
    int status = ERROR_NOT_LOCKED;

    AcquireSRWLockExclusive(&open->lock);

    /* find lock state that matches this range */
    entry = list_search(&open->locks.list, input, lock_range_cmp);
    if (entry) {
        nfs41_lock_state *lock = lock_entry(entry);
        if (lock->delegated) {
            /* if the lock was delegated, remove/free it and return success */
            list_remove(entry);
            free(lock);
            status = NO_ERROR;
        } else
            status = ERROR_LOCKED;
    }

    ReleaseSRWLockExclusive(&open->lock);
    return status;
}

int belle_sip_mutex_lock(belle_sip_mutex_t * hMutex) {
#ifdef BELLE_SIP_WINDOWS_DESKTOP
	WaitForSingleObject(*hMutex, INFINITE);
#else
	AcquireSRWLockExclusive(hMutex);
#endif
	return 0;
}

/// <summary>
/// Locks for writing.
/// </summary>
void RWLock::LockWrite()
{
#ifdef PLATFORM_WIN
	AcquireSRWLockExclusive( &mRwlock );
#else
	pthread_rwlock_wrlock( &mRwlock );
#endif
}

int mutex_lock(struct mutex_handle *mutex)
{
	struct mutex_priv *priv = (struct mutex_priv *)mutex->priv;

	AcquireSRWLockExclusive(&priv->lock);

	return 0;
}

bool MCF_CRT_TlsFreeKey(void *pTlsKey){
	TlsKey *const pKey = pTlsKey;
	if(!pKey){
		SetLastError(ERROR_INVALID_PARAMETER);
		return false;
	}

	AcquireSRWLockExclusive(&g_csKeyMutex);
	{
		MCF_AvlDetach((MCF_AvlNodeHeader *)pKey);
	}
	ReleaseSRWLockExclusive(&g_csKeyMutex);

	TlsObject *pObject = pKey->pLastByKey;
	while(pObject){
		ThreadMap *const pMap = pObject->pMap;

		AcquireSRWLockExclusive(&(pMap->srwLock));
		{
			TlsObject *const pPrev = pObject->pPrevByThread;
			TlsObject *const pNext = pObject->pNextByThread;
			if(pPrev){
				pPrev->pNextByThread = pNext;
			}
			if(pNext){
				pNext->pPrevByThread = pPrev;
			}

			if(pMap->pLastByThread == pObject){
				pMap->pLastByThread = pObject->pPrevByThread;
			}
		}
		ReleaseSRWLockExclusive(&(pMap->srwLock));

		if(pKey->pfnCallback){
			(*pKey->pfnCallback)(pObject->nValue);
		}

		TlsObject *const pTemp = pObject->pPrevByKey;
		free(pObject);
		pObject = pTemp;
	}
	free(pKey);

	return true;
}

 // the code below in _DEBUG build will check that we don't try to recursively lock, 
 // which is not supported by this class.  also checks that you don't unlock without 
 // having locked
 void SimpleRWLock::lock() {
     unsigned me = GetCurrentThreadId();
     int& state = s.getRef();
     dassert( state == 0 );
     state--;
     AcquireSRWLockExclusive(&_lock);
     tid = me; // this is for use in the debugger to see who does have the lock
 }

void qemu_mutex_lock_impl(QemuMutex *mutex, const char *file, const int line)
{
    assert(mutex->initialized);
    trace_qemu_mutex_lock(mutex, file, line);

    AcquireSRWLockExclusive(&mutex->lock);
    trace_qemu_mutex_locked(mutex, file, line);
}

	void ui::remove(char type)
	{
		AcquireSRWLockExclusive(&uilock);

		delete elements[type];
		elements.erase(type);

		ReleaseSRWLockExclusive(&uilock);
	}

int
pthread_rwlock_wrlock(pthread_rwlock_t *rwlock)
{
	AcquireSRWLockExclusive(&rwlock->rwlock);

	rwlock->exclusive_locked = GetCurrentThreadId();

	return (0);
}

//worker thread
DWORD WINAPI WorkerThread(LPVOID lpParam)
{
    CSocketSever* pSocketServer = (CSocketSever*)lpParam;
    int i = 0;
    fd_set fdread;
    struct timeval tv = {0, 50};
    char szMessage[nMsgSize];
    memset(szMessage, 0, nMsgSize);
    while(TRUE)
    {
        // set fdread初始化为空
        FD_ZERO(&fdread);
        for(i = 0; i < pSocketServer->m_iTotalConn; i++)
                //将client socket加入fdread set
                FD_SET(pSocketServer->m_ClientSocketArr[i], &fdread);
        int ret = select(0, &fdread, NULL, NULL, &tv);
        if (ret == 0)
        {
            // Time expired 
            continue;
        }
        for(i = 0; i < pSocketServer->m_iTotalConn; i++)
        {
           if( FD_ISSET( pSocketServer->m_ClientSocketArr[i], &fdread ) )
            {
                    memset(szMessage, 0, nMsgSize);
                    ret = recv(pSocketServer->m_ClientSocketArr[i], szMessage, nMsgSize,0);
                    if ( ret == 0 || ( ret == SOCKET_ERROR && WSAGetLastError() ) )
                    {
                            //Client socket closed
                            cout << "Client socket " << pSocketServer->m_ClientSocketArr[i] << "closed." << endl;
                            closesocket( pSocketServer->m_ClientSocketArr[i]);
                            pSocketServer->m_ClientSocketArr[i--] = pSocketServer->m_ClientSocketArr[--pSocketServer->m_iTotalConn];
                    }
                    else
                    {
                            string heart = szMessage;
                            if (heart.find("心跳包") != heart.npos)
                            {
                                //cout << szMessage << endl;
                                continue;
                            }
                            //接入业务处理部分
                            g_pos = strlen(LogBuffer);
                            AcquireSRWLockExclusive(&srwTest);
                            sprintf(LogBuffer + g_pos, "%s\n", szMessage);
                            ReleaseSRWLockExclusive(&srwTest);

                            pSocketServer->m_pRTHandleData->GetClientSocket(pSocketServer->m_ClientSocketArr[i]);
                            pSocketServer->m_pRTHandleData->HandleData(szMessage, ret); 

                    }
            }
        }
    }
    return 0;
}

int ts_tree_add(ts_tree_t* ts_tree, ts_tree_node_t* node, uintptr_t key) {
  int r;

  AcquireSRWLockExclusive(&ts_tree->lock);
  r = tree_add(&ts_tree->tree, &node->tree_node, key);
  ReleaseSRWLockExclusive(&ts_tree->lock);

  return r;
}