gogf
diff --git a/‎.github/workflows/gf.yml‎
Lines changed: 6 additions & 6 deletions b/‎.github/workflows/gf.yml‎
Lines changed: 6 additions & 6 deletions
diff --git a/‎cmd/gf/go.mod‎
Lines changed: 0 additions & 3 deletions b/‎cmd/gf/go.mod‎
Lines changed: 0 additions & 3 deletions
diff --git a/‎cmd/gf/go.sum‎
Lines changed: 1 addition & 74 deletions b/‎cmd/gf/go.sum‎
Lines changed: 1 addition & 74 deletions
diff --git a/‎container/gpool/gpool.go‎
Lines changed: 7 additions & 0 deletions b/‎container/gpool/gpool.go‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎container/gpool/gpool_z_example_test.go‎
Lines changed: 13 additions & 12 deletions b/‎container/gpool/gpool_z_example_test.go‎
Lines changed: 13 additions & 12 deletions
diff --git a/‎container/gqueue/gqueue.go‎
Lines changed: 43 additions & 42 deletions b/‎container/gqueue/gqueue.go‎
Lines changed: 43 additions & 42 deletions
@@ -37,7 +37,7 @@ jobs:
     services:
       # Redis backend server.
       redis:
-        image  : loads/redis:latest
+        image  : loads/redis:7.0
         options: >-
           --health-cmd      "redis-cli ping"
           --health-interval 10s
@@ -77,7 +77,7 @@ jobs:
 
       # MSSQL backend server.
       mssql:
-        image: loads/mssqldocker:latest
+        image: loads/mssqldocker:14.0.3391.2
         env:
           ACCEPT_EULA:    Y
           SA_PASSWORD:    LoremIpsum86
@@ -94,25 +94,25 @@ jobs:
           --health-retries 10
 
       # ClickHouse backend server.
-      # docker run -d --name clickhouse -p 9000:9000 -p 8123:8123 -p 9001:9001 loads/clickhouse-server:latest
+      # docker run -d --name clickhouse -p 9000:9000 -p 8123:8123 -p 9001:9001 loads/clickhouse-server:22.1.3.7
       clickhouse-server:
-        image: loads/clickhouse-server:latest
+        image: loads/clickhouse-server:22.1.3.7
         ports:
           - 9000:9000
           - 8123:8123
           - 9001:9001
 
       # Polaris backend server.
       polaris:
-        image: loads/polaris-server-standalone:latest
+        image: loads/polaris-server-standalone:1.11.2
         ports:
           - 8090:8090
           - 8091:8091
           - 8093:8093
 
       # Oracle 11g server
       oracle-server:
-        image: loads/oracle-xe-11g-r2:latest
+        image: loads/oracle-xe-11g-r2:11.2.0
         env:
           ORACLE_ALLOW_REMOTE: true
           ORACLE_SID: XE
 
@@ -15,16 +15,13 @@ require (
 
 require (
 	github.com/BurntSushi/toml v1.2.1 // indirect
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/clbanning/mxj/v2 v2.5.5 // indirect
 	github.com/denisenkom/go-mssqldb v0.11.0 // indirect
-	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/fatih/color v1.13.0 // indirect
 	github.com/fsnotify/fsnotify v1.5.4 // indirect
 	github.com/glebarez/go-sqlite v1.17.3 // indirect
 	github.com/go-logr/logr v1.2.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/go-redis/redis/v8 v8.11.5 // indirect
 	github.com/go-sql-driver/mysql v1.6.0 // indirect
 	github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe // indirect
 	github.com/google/uuid v1.3.0 // indirect
 
@@ -84,6 +84,13 @@ func (p *Pool) Put(value interface{}) error {
 	return nil
 }
 
+// MustPut puts an item to pool, it panics if any error occurs.
+func (p *Pool) MustPut(value interface{}) {
+	if err := p.Put(value); err != nil {
+		panic(err)
+	}
+}
+
 // Clear clears pool, which means it will remove all items from pool.
 func (p *Pool) Clear() {
 	if p.ExpireFunc != nil {
 
@@ -61,7 +61,7 @@ func ExamplePool_Put() {
 	// conn.(*DBConn).Conn.QueryContext(context.Background(), "select * from user")
 
 	// put back conn
-	dbConnPool.Put(conn)
+	dbConnPool.MustPut(conn)
 
 	fmt.Println(conn.(*DBConn).Limit)
 
@@ -88,8 +88,8 @@ func ExamplePool_Clear() {
 		})
 
 	conn, _ := dbConnPool.Get()
-	dbConnPool.Put(conn)
-	dbConnPool.Put(conn)
+	dbConnPool.MustPut(conn)
+	dbConnPool.MustPut(conn)
 	fmt.Println(dbConnPool.Size())
 	dbConnPool.Clear()
 	fmt.Println(dbConnPool.Size())
@@ -144,8 +144,8 @@ func ExamplePool_Size() {
 
 	conn, _ := dbConnPool.Get()
 	fmt.Println(dbConnPool.Size())
-	dbConnPool.Put(conn)
-	dbConnPool.Put(conn)
+	dbConnPool.MustPut(conn)
+	dbConnPool.MustPut(conn)
 	fmt.Println(dbConnPool.Size())
 
 	// Output:
@@ -158,21 +158,22 @@ func ExamplePool_Close() {
 		Conn  *sql.Conn
 		Limit int
 	}
-
-	dbConnPool := gpool.New(time.Hour,
-		func() (interface{}, error) {
+	var (
+		newFunc = func() (interface{}, error) {
 			dbConn := new(DBConn)
 			dbConn.Limit = 10
 			return dbConn, nil
-		},
-		func(i interface{}) {
+		}
+		closeFunc = func(i interface{}) {
 			fmt.Println("Close The Pool")
 			// sample : close db conn
 			// i.(DBConn).Conn.Close()
-		})
+		}
+	)
+	dbConnPool := gpool.New(time.Hour, newFunc, closeFunc)
 
 	conn, _ := dbConnPool.Get()
-	dbConnPool.Put(conn)
+	dbConnPool.MustPut(conn)
 
 	dbConnPool.Close()
 
 
@@ -27,6 +27,7 @@ import (
 // Queue is a concurrent-safe queue built on doubly linked list and channel.
 type Queue struct {
 	limit  int              // Limit for queue size.
+	length *gtype.Int64     // Queue length.
 	list   *glist.List      // Underlying list structure for data maintaining.
 	closed *gtype.Bool      // Whether queue is closed.
 	events chan struct{}    // Events for data writing.
@@ -44,6 +45,7 @@ const (
 func New(limit ...int) *Queue {
 	q := &Queue{
 		closed: gtype.NewBool(),
+		length: gtype.NewInt64(),
 	}
 	if len(limit) > 0 && limit[0] > 0 {
 		q.limit = limit[0]
@@ -57,43 +59,10 @@ func New(limit ...int) *Queue {
 	return q
 }
 
-// asyncLoopFromListToChannel starts an asynchronous goroutine,
-// which handles the data synchronization from list `q.list` to channel `q.C`.
-func (q *Queue) asyncLoopFromListToChannel() {
-	defer func() {
-		if q.closed.Val() {
-			_ = recover()
-		}
-	}()
-	for !q.closed.Val() {
-		<-q.events
-		for !q.closed.Val() {
-			if length := q.list.Len(); length > 0 {
-				if length > defaultBatchSize {
-					length = defaultBatchSize
-				}
-				for _, v := range q.list.PopFronts(length) {
-					// When q.C is closed, it will panic here, especially q.C is being blocked for writing.
-					// If any error occurs here, it will be caught by recover and be ignored.
-					q.C <- v
-				}
-			} else {
-				break
-			}
-		}
-		// Clear q.events to remain just one event to do the next synchronization check.
-		for i := 0; i < len(q.events)-1; i++ {
-			<-q.events
-		}
-	}
-	// It should be here to close `q.C` if `q` is unlimited size.
-	// It's the sender's responsibility to close channel when it should be closed.
-	close(q.C)
-}
-
 // Push pushes the data `v` into the queue.
 // Note that it would panic if Push is called after the queue is closed.
 func (q *Queue) Push(v interface{}) {
+	q.length.Add(1)
 	if q.limit > 0 {
 		q.C <- v
 	} else {
@@ -107,7 +76,9 @@ func (q *Queue) Push(v interface{}) {
 // Pop pops an item from the queue in FIFO way.
 // Note that it would return nil immediately if Pop is called after the queue is closed.
 func (q *Queue) Pop() interface{} {
-	return <-q.C
+	item := <-q.C
+	q.length.Add(-1)
+	return item
 }
 
 // Close closes the queue.
@@ -130,15 +101,45 @@ func (q *Queue) Close() {
 // Len returns the length of the queue.
 // Note that the result might not be accurate as there's an
 // asynchronous channel reading the list constantly.
-func (q *Queue) Len() (length int) {
-	if q.list != nil {
-		length += q.list.Len()
-	}
-	length += len(q.C)
-	return
+func (q *Queue) Len() (length int64) {
+	return q.length.Val()
 }
 
 // Size is alias of Len.
-func (q *Queue) Size() int {
+func (q *Queue) Size() int64 {
 	return q.Len()
 }
+
+// asyncLoopFromListToChannel starts an asynchronous goroutine,
+// which handles the data synchronization from list `q.list` to channel `q.C`.
+func (q *Queue) asyncLoopFromListToChannel() {
+	defer func() {
+		if q.closed.Val() {
+			_ = recover()
+		}
+	}()
+	for !q.closed.Val() {
+		<-q.events
+		for !q.closed.Val() {
+			if length := q.list.Len(); length > 0 {
+				if length > defaultBatchSize {
+					length = defaultBatchSize
+				}
+				for _, v := range q.list.PopFronts(length) {
+					// When q.C is closed, it will panic here, especially q.C is being blocked for writing.
+					// If any error occurs here, it will be caught by recover and be ignored.
+					q.C <- v
+				}
+			} else {
+				break
+			}
+		}
+		// Clear q.events to remain just one event to do the next synchronization check.
+		for i := 0; i < len(q.events)-1; i++ {
+			<-q.events
+		}
+	}
+	// It should be here to close `q.C` if `q` is unlimited size.
+	// It's the sender's responsibility to close channel when it should be closed.
+	close(q.C)
+}