From f25571a0a9e908362561deee18505b17bcd9fad9 Mon Sep 17 00:00:00 2001
From: hailaz <739476267@qq.com>
Date: Mon, 24 Jun 2019 19:34:53 +0800
Subject: [PATCH] Improve gmlock, gmutex, grpool, gmutex unit testing sleep
 time.

---
 g/os/gflock/gflock_unit_test.go       |  8 +--
 g/os/gmlock/gmlock_unit_lock_test.go  | 68 ++++++++++-------------
 g/os/gmlock/gmlock_unit_rlock_test.go | 78 +++++++++++++--------------
 g/os/gmutex/gmutex_unit_test.go       | 42 +++++++--------
 g/os/grpool/grpool_unit_test.go       |  2 +-
 5 files changed, 93 insertions(+), 105 deletions(-)

diff --git a/g/os/gflock/gflock_unit_test.go b/g/os/gflock/gflock_unit_test.go
index d3f1e6c3e..e24bbdee7 100644
--- a/g/os/gflock/gflock_unit_test.go
+++ b/g/os/gflock/gflock_unit_test.go
@@ -49,22 +49,22 @@ func Test_GFlock_Lock(t *testing.T) {
 		go func() {
 			lock.Lock()
 			array.Append(1)
-			time.Sleep(200 * time.Millisecond)
+			time.Sleep(300 * time.Millisecond)
 			lock.Unlock()
 		}()
 
 		go func() {
-			time.Sleep(50 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			lock2.Lock()
 			array.Append(1)
 			lock2.Unlock()
 		}()
 
-		time.Sleep(50 * time.Millisecond)
-		gtest.Assert(array.Len(), 1)
 		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(100 * time.Millisecond)
+		gtest.Assert(array.Len(), 1)
+		time.Sleep(200 * time.Millisecond)
 		gtest.Assert(array.Len(), 2)
 	})
 }
diff --git a/g/os/gmlock/gmlock_unit_lock_test.go b/g/os/gmlock/gmlock_unit_lock_test.go
index 27ddbdb1d..da1132d4b 100644
--- a/g/os/gmlock/gmlock_unit_lock_test.go
+++ b/g/os/gmlock/gmlock_unit_lock_test.go
@@ -22,26 +22,21 @@ func Test_Locker_Lock(t *testing.T) {
 		go func() {
 			gmlock.Lock(key)
 			array.Append(1)
-			time.Sleep(50 * time.Millisecond)
-			array.Append(1)
+			time.Sleep(300 * time.Millisecond)
 			gmlock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
-			gmlock.Lock(key)
-			array.Append(1)
 			time.Sleep(100 * time.Millisecond)
+			gmlock.Lock(key)
 			array.Append(1)
 			gmlock.Unlock(key)
 		}()
-		time.Sleep(10 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
-		time.Sleep(50 * time.Millisecond)
-		gtest.Assert(array.Len(), 3)
-		time.Sleep(50 * time.Millisecond)
-		gtest.Assert(array.Len(), 3)
-		time.Sleep(50 * time.Millisecond)
-		gtest.Assert(array.Len(), 4)
+		time.Sleep(100 * time.Millisecond)
+		gtest.Assert(array.Len(), 1)
+		time.Sleep(200 * time.Millisecond)
+		gtest.Assert(array.Len(), 2)
 		gmlock.Remove(key)
 	})
 
@@ -52,26 +47,21 @@ func Test_Locker_Lock(t *testing.T) {
 		go func() {
 			lock.Lock(key)
 			array.Append(1)
-			time.Sleep(50 * time.Millisecond)
-			array.Append(1)
+			time.Sleep(300 * time.Millisecond)
 			lock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
-			lock.Lock(key)
-			array.Append(1)
 			time.Sleep(100 * time.Millisecond)
+			lock.Lock(key)
 			array.Append(1)
 			lock.Unlock(key)
 		}()
-		time.Sleep(10 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
-		time.Sleep(50 * time.Millisecond)
-		gtest.Assert(array.Len(), 3)
-		time.Sleep(50 * time.Millisecond)
-		gtest.Assert(array.Len(), 3)
-		time.Sleep(50 * time.Millisecond)
-		gtest.Assert(array.Len(), 4)
+		time.Sleep(100 * time.Millisecond)
+		gtest.Assert(array.Len(), 1)
+		time.Sleep(200 * time.Millisecond)
+		gtest.Assert(array.Len(), 2)
 		lock.Clear()
 	})
 
@@ -84,26 +74,26 @@ func Test_Locker_TryLock(t *testing.T) {
 		go func() {
 			gmlock.Lock(key)
 			array.Append(1)
-			time.Sleep(200 * time.Millisecond)
+			time.Sleep(300 * time.Millisecond)
 			gmlock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(150 * time.Millisecond)
 			if gmlock.TryLock(key) {
 				array.Append(1)
 				gmlock.Unlock(key)
 			}
 		}()
 		go func() {
-			time.Sleep(300 * time.Millisecond)
+			time.Sleep(400 * time.Millisecond)
 			if gmlock.TryLock(key) {
 				array.Append(1)
 				gmlock.Unlock(key)
 			}
 		}()
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(300 * time.Millisecond)
 		gtest.Assert(array.Len(), 2)
@@ -119,20 +109,20 @@ func Test_Locker_LockFunc(t *testing.T) {
 		go func() {
 			gmlock.LockFunc(key, func() {
 				array.Append(1)
-				time.Sleep(50 * time.Millisecond)
+				time.Sleep(300 * time.Millisecond)
 			}) //
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.LockFunc(key, func() {
 				array.Append(1)
 			})
 		}()
-		time.Sleep(10 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1) //
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(200 * time.Millisecond)
 		gtest.Assert(array.Len(), 2)
 	})
 }
@@ -144,24 +134,24 @@ func Test_Locker_TryLockFunc(t *testing.T) {
 		go func() {
 			gmlock.TryLockFunc(key, func() {
 				array.Append(1)
-				time.Sleep(50 * time.Millisecond)
+				time.Sleep(200 * time.Millisecond)
 			})
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.TryLockFunc(key, func() {
 				array.Append(1)
 			})
 		}()
 		go func() {
-			time.Sleep(70 * time.Millisecond)
+			time.Sleep(300 * time.Millisecond)
 			gmlock.TryLockFunc(key, func() {
 				array.Append(1)
 			})
 		}()
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(150 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
-		time.Sleep(100 * time.Millisecond)
+		time.Sleep(400 * time.Millisecond)
 		gtest.Assert(array.Len(), 2)
 	})
 }
diff --git a/g/os/gmlock/gmlock_unit_rlock_test.go b/g/os/gmlock/gmlock_unit_rlock_test.go
index 465435402..3b8b299f5 100644
--- a/g/os/gmlock/gmlock_unit_rlock_test.go
+++ b/g/os/gmlock/gmlock_unit_rlock_test.go
@@ -23,20 +23,19 @@ func Test_Locker_RLock(t *testing.T) {
 		go func() {
 			gmlock.RLock(key)
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
-			array.Append(1)
+			time.Sleep(200 * time.Millisecond)
 			gmlock.RUnlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.Lock(key)
 			array.Append(1)
 			gmlock.Unlock(key)
 		}()
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(200 * time.Millisecond)
-		gtest.Assert(array.Len(), 3)
+		gtest.Assert(array.Len(), 2)
 	})
 
 	//Lock before RLock
@@ -46,16 +45,16 @@ func Test_Locker_RLock(t *testing.T) {
 		go func() {
 			gmlock.Lock(key)
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(200 * time.Millisecond)
 			gmlock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.RLock(key)
 			array.Append(1)
 			gmlock.RUnlock(key)
 		}()
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(200 * time.Millisecond)
 		gtest.Assert(array.Len(), 2)
@@ -68,26 +67,26 @@ func Test_Locker_RLock(t *testing.T) {
 		go func() {
 			gmlock.Lock(key)
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(300 * time.Millisecond)
 			gmlock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.RLock(key)
 			array.Append(1)
 			time.Sleep(200 * time.Millisecond)
 			gmlock.RUnlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.RLock(key)
 			array.Append(1)
 			time.Sleep(200 * time.Millisecond)
 			gmlock.RUnlock(key)
 		}()
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(200 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
-		time.Sleep(500 * time.Millisecond)
+		time.Sleep(200 * time.Millisecond)
 		gtest.Assert(array.Len(), 3)
 	})
 }
@@ -100,17 +99,17 @@ func Test_Locker_TryRLock(t *testing.T) {
 		go func() {
 			gmlock.Lock(key)
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(200 * time.Millisecond)
 			gmlock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			if gmlock.TryRLock(key) {
 				array.Append(1)
 				gmlock.RUnlock(key)
 			}
 		}()
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(150 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(200 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
@@ -123,24 +122,24 @@ func Test_Locker_TryRLock(t *testing.T) {
 		go func() {
 			gmlock.Lock(key)
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(200 * time.Millisecond)
 			gmlock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			if gmlock.TryRLock(key) {
 				array.Append(1)
 				gmlock.RUnlock(key)
 			}
 		}()
 		go func() {
-			time.Sleep(150 * time.Millisecond)
+			time.Sleep(300 * time.Millisecond)
 			if gmlock.TryRLock(key) {
 				array.Append(1)
 				gmlock.RUnlock(key)
 			}
 		}()
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(150 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(200 * time.Millisecond)
 		gtest.Assert(array.Len(), 2)
@@ -155,20 +154,19 @@ func Test_Locker_RLockFunc(t *testing.T) {
 		go func() {
 			gmlock.RLockFunc(key, func() {
 				array.Append(1)
-				time.Sleep(100 * time.Millisecond)
-				array.Append(1)
+				time.Sleep(200 * time.Millisecond)
 			})
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.Lock(key)
 			array.Append(1)
 			gmlock.Unlock(key)
 		}()
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(150 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(200 * time.Millisecond)
-		gtest.Assert(array.Len(), 3)
+		gtest.Assert(array.Len(), 2)
 	})
 
 	//Lock before RLockFunc
@@ -178,16 +176,16 @@ func Test_Locker_RLockFunc(t *testing.T) {
 		go func() {
 			gmlock.Lock(key)
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(200 * time.Millisecond)
 			gmlock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.RLockFunc(key, func() {
 				array.Append(1)
 			})
 		}()
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(200 * time.Millisecond)
 		gtest.Assert(array.Len(), 2)
@@ -200,26 +198,26 @@ func Test_Locker_RLockFunc(t *testing.T) {
 		go func() {
 			gmlock.Lock(key)
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(200 * time.Millisecond)
 			gmlock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.RLockFunc(key, func() {
 				array.Append(1)
 				time.Sleep(200 * time.Millisecond)
 			})
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.RLockFunc(key, func() {
 				array.Append(1)
 				time.Sleep(200 * time.Millisecond)
 			})
 		}()
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
-		time.Sleep(400 * time.Millisecond)
+		time.Sleep(200 * time.Millisecond)
 		gtest.Assert(array.Len(), 3)
 	})
 }
@@ -232,16 +230,16 @@ func Test_Locker_TryRLockFunc(t *testing.T) {
 		go func() {
 			gmlock.Lock(key)
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(200 * time.Millisecond)
 			gmlock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.TryRLockFunc(key, func() {
 				array.Append(1)
 			})
 		}()
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(200 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
@@ -254,22 +252,22 @@ func Test_Locker_TryRLockFunc(t *testing.T) {
 		go func() {
 			gmlock.Lock(key)
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(200 * time.Millisecond)
 			gmlock.Unlock(key)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			gmlock.TryRLockFunc(key, func() {
 				array.Append(1)
 			})
 		}()
 		go func() {
-			time.Sleep(150 * time.Millisecond)
+			time.Sleep(300 * time.Millisecond)
 			gmlock.TryRLockFunc(key, func() {
 				array.Append(1)
 			})
 		}()
-		time.Sleep(20 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(300 * time.Millisecond)
 		gtest.Assert(array.Len(), 2)
diff --git a/g/os/gmutex/gmutex_unit_test.go b/g/os/gmutex/gmutex_unit_test.go
index bad656643..74d42edb1 100644
--- a/g/os/gmutex/gmutex_unit_test.go
+++ b/g/os/gmutex/gmutex_unit_test.go
@@ -21,11 +21,11 @@ func Test_Mutex_RUnlock(t *testing.T) {
 		for index := 0; index < 1000; index++ {
 			go func() {
 				mu.RLockFunc(func() {
-					time.Sleep(100 * time.Millisecond)
+					time.Sleep(200 * time.Millisecond)
 				})
 			}()
 		}
-		time.Sleep(10 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(mu.IsRLocked(), true)
 		gtest.Assert(mu.IsLocked(), true)
 		gtest.Assert(mu.IsWLocked(), false)
@@ -34,7 +34,7 @@ func Test_Mutex_RUnlock(t *testing.T) {
 				mu.RUnlock()
 			}()
 		}
-		time.Sleep(150 * time.Millisecond)
+		time.Sleep(300 * time.Millisecond)
 		gtest.Assert(mu.IsRLocked(), false)
 
 	})
@@ -63,27 +63,27 @@ func Test_Mutex_IsLocked(t *testing.T) {
 		mu := gmutex.New()
 		go func() {
 			mu.LockFunc(func() {
-				time.Sleep(100 * time.Millisecond)
+				time.Sleep(200 * time.Millisecond)
 			})
 		}()
-		time.Sleep(10 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(mu.IsLocked(), true)
 		gtest.Assert(mu.IsWLocked(), true)
 		gtest.Assert(mu.IsRLocked(), false)
-		time.Sleep(110 * time.Millisecond)
+		time.Sleep(300 * time.Millisecond)
 		gtest.Assert(mu.IsLocked(), false)
 		gtest.Assert(mu.IsWLocked(), false)
 
 		go func() {
 			mu.RLockFunc(func() {
-				time.Sleep(100 * time.Millisecond)
+				time.Sleep(200 * time.Millisecond)
 			})
 		}()
-		time.Sleep(10 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(mu.IsRLocked(), true)
 		gtest.Assert(mu.IsLocked(), true)
 		gtest.Assert(mu.IsWLocked(), false)
-		time.Sleep(110 * time.Millisecond)
+		time.Sleep(300 * time.Millisecond)
 		gtest.Assert(mu.IsRLocked(), false)
 	})
 }
@@ -95,7 +95,7 @@ func Test_Mutex_Unlock(t *testing.T) {
 		go func() {
 			mu.LockFunc(func() {
 				array.Append(1)
-				time.Sleep(200 * time.Millisecond)
+				time.Sleep(300 * time.Millisecond)
 			})
 		}()
 		go func() {
@@ -112,14 +112,14 @@ func Test_Mutex_Unlock(t *testing.T) {
 		}()
 
 		go func() {
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(200 * time.Millisecond)
 			mu.Unlock()
 			mu.Unlock()
 			mu.Unlock()
 			mu.Unlock()
 		}()
 
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(400 * time.Millisecond)
 		gtest.Assert(array.Len(), 3)
@@ -189,17 +189,17 @@ func Test_Mutex_RLockFunc(t *testing.T) {
 		go func() {
 			mu.LockFunc(func() {
 				array.Append(1)
-				time.Sleep(200 * time.Millisecond)
+				time.Sleep(300 * time.Millisecond)
 			})
 		}()
 		go func() {
-			time.Sleep(50 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			mu.RLockFunc(func() {
 				array.Append(1)
 				time.Sleep(100 * time.Millisecond)
 			})
 		}()
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
@@ -211,21 +211,21 @@ func Test_Mutex_RLockFunc(t *testing.T) {
 		mu := gmutex.New()
 		array := garray.New()
 		go func() {
-			time.Sleep(50 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			mu.RLockFunc(func() {
 				array.Append(1)
 				time.Sleep(100 * time.Millisecond)
 			})
 		}()
 		go func() {
-			time.Sleep(50 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			mu.RLockFunc(func() {
 				array.Append(1)
 				time.Sleep(100 * time.Millisecond)
 			})
 		}()
 		go func() {
-			time.Sleep(50 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			mu.RLockFunc(func() {
 				array.Append(1)
 				time.Sleep(100 * time.Millisecond)
@@ -244,7 +244,7 @@ func Test_Mutex_TryRLockFunc(t *testing.T) {
 		go func() {
 			mu.LockFunc(func() {
 				array.Append(1)
-				time.Sleep(200 * time.Millisecond)
+				time.Sleep(300 * time.Millisecond)
 			})
 		}()
 		go func() {
@@ -255,13 +255,13 @@ func Test_Mutex_TryRLockFunc(t *testing.T) {
 		}()
 		for index := 0; index < 1000; index++ {
 			go func() {
-				time.Sleep(300 * time.Millisecond)
+				time.Sleep(400 * time.Millisecond)
 				mu.TryRLockFunc(func() {
 					array.Append(1)
 				})
 			}()
 		}
-		time.Sleep(10 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
 		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), 1)
diff --git a/g/os/grpool/grpool_unit_test.go b/g/os/grpool/grpool_unit_test.go
index b5c900b2d..90ce424bd 100644
--- a/g/os/grpool/grpool_unit_test.go
+++ b/g/os/grpool/grpool_unit_test.go
@@ -31,7 +31,7 @@ func Test_Basic(t *testing.T) {
 			})
 		}
 		wg.Wait()
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(100 * time.Millisecond)
 		gtest.Assert(array.Len(), size)
 		gtest.Assert(grpool.Jobs(), 0)
 		gtest.Assert(grpool.Size(), 0)