fix TC_ThreadRWLocker tryWriteLock & tryReadLock bug

util/include/util/tc_thread_rwlock.h

@@ -45,73 +45,19 @@ protected:
 	{
 	public:
 		//获取读锁
-		void readLock()
-		{
-			//加锁, 直到可读
-			unique_lock<mutex> lck(_mutex);
-			_cond.wait(lck, std::bind(&TC_SharedMutex::isReadCond, this));
-			_readCount++;
-		}
+		void readLock();
 
-		bool tryReadLock()
-		{
-			unique_lock<mutex> lck(_mutex);
-			if(_cond.wait_for(lck, std::chrono::seconds(0)) == std::cv_status::timeout)
-			{
-				return false;
-			}
-
-			if(isReadCond())
-			{
-				_readCount++;
-				return true;
-			}
-
-			return false;
-		}
+		bool tryReadLock();
 
 		//解读锁
-		void unReadLock()
-		{
-			unique_lock<mutex> lck(_mutex);
-			_readCount--;
-			_cond.notify_all();
-		}
-		
-		void writeLock()
-		{
-			unique_lock<mutex> lck(_mutex);
-			_cond.wait(lck, std::bind([](const bool *is_w, const size_t *read_c) -> bool
-			{
-				return false == *is_w && 0 == *read_c;
-			}, &_isWrite, &_readCount));
+		void unReadLock();
 
-			_isWrite = true;
-		}
+		void writeLock();
 
-		bool tryWriteLock()
-		{
-			unique_lock<mutex> lck(_mutex);
-			if(_cond.wait_for(lck, std::chrono::seconds(0)) == std::cv_status::timeout)
-			{
-				return false;
-			}
-
-			if(isWriteCond())
-			{
-				_isWrite = true;
-				return true;
-			}
-
-			return false;
-		}
+		bool tryWriteLock();
+
+		void unWriteLock();
 
-		void unWriteLock()
-		{
-			unique_lock<mutex> lck(_mutex);
-			_isWrite = false;
-			_cond.notify_all();
-		}
 	private:
 		// 锁
 		mutex _mutex;

util/src/tc_thread_rwlock.cpp

@@ -19,47 +19,118 @@
 #include <iostream>
 #include <cassert>
 
-namespace tars
-{
+namespace tars {
 
-TC_ThreadRWLocker::TC_ThreadRWLocker()
-{
-}
+    TC_ThreadRWLocker::TC_ThreadRWLocker() {
+    }
 
-TC_ThreadRWLocker::~TC_ThreadRWLocker()
-{
-}
+    TC_ThreadRWLocker::~TC_ThreadRWLocker() {
+    }
 
-void TC_ThreadRWLocker::readLock() const
-{
-	_mutex.readLock();
-}
+    void TC_ThreadRWLocker::readLock() const {
+        _mutex.readLock();
+    }
 
 
-void TC_ThreadRWLocker::writeLock() const
-{
-	_mutex.writeLock();
-}
+    void TC_ThreadRWLocker::writeLock() const {
+        _mutex.writeLock();
+    }
 
-bool TC_ThreadRWLocker::tryReadLock() const
-{
-	return _mutex.tryReadLock();	
-}
+    bool TC_ThreadRWLocker::tryReadLock() const {
+        return _mutex.tryReadLock();
+    }
 
-bool TC_ThreadRWLocker::tryWriteLock() const
-{
-	return _mutex.tryWriteLock();	
-}
+    bool TC_ThreadRWLocker::tryWriteLock() const {
+        return _mutex.tryWriteLock();
+    }
 
-void TC_ThreadRWLocker::unReadLock() const
-{
-	_mutex.unReadLock();	
-}
+    void TC_ThreadRWLocker::unReadLock() const {
+        _mutex.unReadLock();
+    }
 
-void TC_ThreadRWLocker::unWriteLock() const
-{
-	_mutex.unWriteLock();	
-}
+    void TC_ThreadRWLocker::unWriteLock() const {
+        _mutex.unWriteLock();
+    }
+
+    //获取读锁
+    void TC_ThreadRWLocker::TC_SharedMutex::readLock() {
+        //加锁, 直到可读
+        unique_lock<mutex> lck(_mutex);
+        _cond.wait(lck, [this]() { return isReadCond(); });
+        _readCount++;
+    }
+
+    bool TC_ThreadRWLocker::TC_SharedMutex::tryReadLock() {
+        if(isReadCond() && _mutex.try_lock()) {
+            if (isReadCond()) {
+                _readCount++;
+                _mutex.unlock();
+                return true;
+            }
+
+            _mutex.unlock();
+        }
+
+        return false;
+
+//        unique_lock<mutex> lck(_mutex);
+//        if (_cond.wait_for(lck, std::chrono::seconds(0)) == std::cv_status::timeout) {
+//            return false;
+//        }
+//
+//        if (isReadCond()) {
+//            _readCount++;
+//            return true;
+//        }
+//
+//        return false;
+    }
+
+    //解读锁
+    void TC_ThreadRWLocker::TC_SharedMutex::unReadLock() {
+        unique_lock<mutex> lck(_mutex);
+        _readCount--;
+        _cond.notify_all();
+    }
+
+    void TC_ThreadRWLocker::TC_SharedMutex::writeLock() {
+        unique_lock<mutex> lck(_mutex);
+        _cond.wait(lck, [this]() { return isWriteCond(); });
+
+        _isWrite = true;
+    }
+
+    bool TC_ThreadRWLocker::TC_SharedMutex::tryWriteLock() {
+        if(isWriteCond() && _mutex.try_lock()) {
+            if (isWriteCond()) {
+                _isWrite = true;
+                _mutex.unlock();
+                return true;
+            }
+
+            _mutex.unlock();
+        }
+
+        return false;
+//
+//        unique_lock<mutex> lck(_mutex);
+//        if (_cond.wait_for(lck, std::chrono::seconds(0)) == std::cv_status::timeout) {
+//            return false;
+//        }
+//
+//        if (isWriteCond()) {
+//            _isWrite = true;
+//            return true;
+//        }
+//
+//        return false;
+    }
+
+    void TC_ThreadRWLocker::TC_SharedMutex::unWriteLock() {
+        unique_lock<mutex> lck(_mutex);
+        _isWrite = false;
+        _cond.notify_all();
+    }
 
 }