database/gdb: fix deadlock when orm operations perform in cache function from gcache (#3585)

.github/workflows/golangci-lint.yml

@@ -47,8 +47,8 @@ jobs:
         with:
           go-version: ${{ matrix.go-version }}
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v4
+        uses: golangci/golangci-lint-action@v6
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.56.2
+          version: v1.58.2
           args: --timeout 3m0s

.golangci.yml

@@ -38,7 +38,7 @@ linters:
   # Custom enable linters we want to use.
   enable:
     - errcheck      # Errcheck is a program for checking for unchecked errors in go programs.
-    - errchkjson    # Checks types passed to the json encoding functions. Reports unsupported types and optionally reports occasions, where the check for the returned error can be omitted.
+    - errchkjson    # Checks types passed to the JSON encoding functions. Reports unsupported types and optionally reports occasions, where the check for the returned error can be omitted.
     - funlen        # Tool for detection of long functions
     - goconst       # Finds repeated strings that could be replaced by a constant
     - gocritic      # Provides diagnostics that check for bugs, performance and style issues.
@@ -172,10 +172,6 @@ linters-settings:
 
   # https://golangci-lint.run/usage/linters/#gosimple
   gosimple:
-    # Select the Go version to target.
-    # Default: 1.13
-    # Deprecated: use the global `run.go` instead.
-    go: "1.15"
     # Sxxxx checks in https://staticcheck.io/docs/configuration/options/#checks
     # Default: ["*"]
     checks: [
@@ -184,9 +180,6 @@ linters-settings:
 
   # https://golangci-lint.run/usage/linters/#govet
   govet:
-    # Report about shadowed variables.
-    # Default: false
-    check-shadowing: true
     # Settings per analyzer.
     settings:
       # Analyzer name, run `go tool vet help` to see all analyzers.
@@ -259,10 +252,6 @@ linters-settings:
 
   # https://golangci-lint.run/usage/linters/#staticcheck
   staticcheck:
-    # Select the Go version to target.
-    # Default: "1.13"
-    # Deprecated: use the global `run.go` instead.
-    go: "1.20"
     # SAxxxx checks in https://staticcheck.io/docs/configuration/options/#checks
     # Default: ["*"]
     checks: [ "all","-SA1019","-SA4015","-SA1029","-SA1016","-SA9003","-SA4006","-SA6003" ]

contrib/config/consul/consul.go

@@ -11,13 +11,14 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/hashicorp/consul/api"
+	"github.com/hashicorp/consul/api/watch"
+
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gcfg"
 	"github.com/gogf/gf/v2/os/glog"
-	"github.com/hashicorp/consul/api"
-	"github.com/hashicorp/consul/api/watch"
 )
 
 // Config is the configuration object for consul client.
@@ -156,22 +157,28 @@ func (c *Client) addWatcher() (err error) {
 			return
 		}
 
-		if err := c.doUpdate(v.Value); err != nil {
-			c.config.Logger.Errorf(context.Background(),
+		if err = c.doUpdate(v.Value); err != nil {
+			c.config.Logger.Errorf(
+				context.Background(),
 				"watch config from consul path %+v update failed: %s",
-				c.config.Path, err)
+				c.config.Path, err,
+			)
 		}
 	}
 
 	plan.Datacenter = c.config.ConsulConfig.Datacenter
 	plan.Token = c.config.ConsulConfig.Token
 
-	go func() {
-		if err := plan.Run(c.config.ConsulConfig.Address); err != nil {
-			c.config.Logger.Errorf(context.Background(),
-				"watch config from consul path %+v plan start failed: %s",
-				c.config.Path, err)
-		}
-	}()
+	go c.startAsynchronousWatch(plan)
 	return nil
 }
+
+func (c *Client) startAsynchronousWatch(plan *watch.Plan) {
+	if err := plan.Run(c.config.ConsulConfig.Address); err != nil {
+		c.config.Logger.Errorf(
+			context.Background(),
+			"watch config from consul path %+v plan start failed: %s",
+			c.config.Path, err,
+		)
+	}
+}

contrib/config/kubecm/kubecm.go

@@ -164,7 +164,11 @@ func (c *Client) doWatch(ctx context.Context, namespace string) (err error) {
 			c.config.ConfigMap, namespace,
 		)
 	}
-	go func() {
+	go c.startAsynchronousWatch(ctx, namespace, watchHandler)
+	return nil
+}
+
+func (c *Client) startAsynchronousWatch(ctx context.Context, namespace string, watchHandler watch.Interface) {
 	for {
 		event := <-watchHandler.ResultChan()
 		switch event.Type {
@@ -172,6 +176,4 @@ func (c *Client) doWatch(ctx context.Context, namespace string) (err error) {
 			_ = c.doUpdate(ctx, namespace)
 		}
 	}
-	}()
-	return nil
 }

contrib/config/polaris/polaris.go

@@ -158,14 +158,18 @@ func (c *Client) doWatch(ctx context.Context) (err error) {
 	if !c.config.Watch {
 		return nil
 	}
-	var changeChan = c.client.AddChangeListenerWithChannel()
-	go func() {
+	go c.startAsynchronousWatch(
+		ctx,
+		c.client.AddChangeListenerWithChannel(),
+	)
+	return nil
+}
+
+func (c *Client) startAsynchronousWatch(ctx context.Context, changeChan <-chan model.ConfigFileChangeEvent) {
 	for {
 		select {
 		case <-changeChan:
 			_ = c.doUpdate(ctx)
 		}
 	}
-	}()
-	return nil
 }

contrib/rpc/grpcx/grpcx_grpc_server.go

@@ -108,11 +108,7 @@ func (s *GrpcServer) Run() {
 	}
 
 	// Start listening.
-	go func() {
-		if err = s.Server.Serve(s.listener); err != nil {
-			s.Logger().Fatalf(ctx, `%+v`, err)
-		}
-	}()
+	go s.doServeAsynchronously(ctx)
 
 	// Service register.
 	s.doServiceRegister()
@@ -124,6 +120,12 @@ func (s *GrpcServer) Run() {
 	s.doSignalListen()
 }
 
+func (s *GrpcServer) doServeAsynchronously(ctx context.Context) {
+	if err := s.Server.Serve(s.listener); err != nil {
+		s.Logger().Fatalf(ctx, `%+v`, err)
+	}
+}
+
 // doSignalListen does signal listening and handling for gracefully shutdown.
 func (s *GrpcServer) doSignalListen() {
 	var ctx = context.Background()
@@ -204,10 +206,12 @@ func (s *GrpcServer) doServiceDeregister() {
 // Start starts the server in no-blocking way.
 func (s *GrpcServer) Start() {
 	s.waitGroup.Add(1)
-	go func() {
+	go s.doStartAsynchronously()
+}
+
+func (s *GrpcServer) doStartAsynchronously() {
 	defer s.waitGroup.Done()
 	s.Run()
-	}()
 }
 
 // Wait works with Start, which blocks current goroutine until the server stops.

contrib/rpc/grpcx/internal/tracing/tracing_interceptor.go

@@ -139,16 +139,15 @@ const (
 )
 
 func wrapClientStream(s grpc.ClientStream, desc *grpc.StreamDesc) *clientStream {
-	events := make(chan streamEvent)
-	eventsDone := make(chan struct{})
-	finished := make(chan error)
-
+	var (
+		events     = make(chan streamEvent)
+		eventsDone = make(chan struct{})
+		finished   = make(chan error)
+	)
 	go func() {
 		defer close(eventsDone)
-
 		// Both streams have to be closed
 		state := byte(0)
-
 		for event := range events {
 			switch event.Type {
 			case closeEvent:

database/gdb/gdb.go

@@ -268,6 +268,7 @@ type Core struct {
 	logger        glog.ILogger    // Logger for logging functionality.
 	config        *ConfigNode     // Current config node.
 	dynamicConfig dynamicConfig   // Dynamic configurations, which can be changed in runtime.
+	innerMemCache *gcache.Cache
 }
 
 type dynamicConfig struct {
@@ -525,9 +526,6 @@ var (
 	// allDryRun sets dry-run feature for all database connections.
 	// It is commonly used for command options for convenience.
 	allDryRun = false
-
-	// tableFieldsMap caches the table information retrieved from database.
-	tableFieldsMap = gmap.NewStrAnyMap(true)
 )
 
 func init() {
@@ -593,6 +591,7 @@ func newDBByConfigNode(node *ConfigNode, group string) (db DB, err error) {
 		links:         gmap.New(true),
 		logger:        glog.New(),
 		config:        node,
+		innerMemCache: gcache.New(),
 		dynamicConfig: dynamicConfig{
 			MaxIdleConnCount: node.MaxIdleConnCount,
 			MaxOpenConnCount: node.MaxOpenConnCount,

database/gdb/gdb_core.go

@@ -22,6 +22,7 @@ import (
 	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/internal/reflection"
 	"github.com/gogf/gf/v2/internal/utils"
+	"github.com/gogf/gf/v2/os/gcache"
 	"github.com/gogf/gf/v2/text/gregex"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
@@ -737,20 +738,27 @@ func (c *Core) HasTable(name string) (bool, error) {
 	return false, nil
 }
 
+func (c *Core) GetInnerMemCache() *gcache.Cache {
+	return c.innerMemCache
+}
+
 // GetTablesWithCache retrieves and returns the table names of current database with cache.
 func (c *Core) GetTablesWithCache() ([]string, error) {
 	var (
 		ctx           = c.db.GetCtx()
-		cacheKey = fmt.Sprintf(`Tables: %s`, c.db.GetGroup())
+		cacheKey      = fmt.Sprintf(`Tables:%s`, c.db.GetGroup())
+		cacheDuration = gcache.DurationNoExpire
+		innerMemCache = c.GetInnerMemCache()
 	)
-	result, err := c.GetCache().GetOrSetFuncLock(
-		ctx, cacheKey, func(ctx context.Context) (interface{}, error) {
+	result, err := innerMemCache.GetOrSetFuncLock(
+		ctx, cacheKey,
+		func(ctx context.Context) (interface{}, error) {
 			tableList, err := c.db.Tables(ctx)
 			if err != nil {
-				return false, err
+				return nil, err
 			}
 			return tableList, nil
-		}, 0,
+		}, cacheDuration,
 	)
 	if err != nil {
 		return nil, err

database/gdb/gdb_core_utility.go

@@ -11,12 +11,10 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/gogf/gf/v2/crypto/gmd5"
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/text/gregex"
 	"github.com/gogf/gf/v2/text/gstr"
-	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/gutil"
 )
 
@@ -144,22 +142,40 @@ func (c *Core) TableFields(ctx context.Context, table string, schema ...string)
 
 // ClearTableFields removes certain cached table fields of current configuration group.
 func (c *Core) ClearTableFields(ctx context.Context, table string, schema ...string) (err error) {
-	tableFieldsMap.Remove(fmt.Sprintf(
-		`%s%s@%s#%s`,
-		cachePrefixTableFields,
+	tableFieldsCacheKey := genTableFieldsCacheKey(
 		c.db.GetGroup(),
 		gutil.GetOrDefaultStr(c.db.GetSchema(), schema...),
 		table,
-	))
+	)
+	_, err = c.innerMemCache.Remove(ctx, tableFieldsCacheKey)
 	return
 }
 
 // ClearTableFieldsAll removes all cached table fields of current configuration group.
 func (c *Core) ClearTableFieldsAll(ctx context.Context) (err error) {
 	var (
-		keys        = tableFieldsMap.Keys()
-		cachePrefix = fmt.Sprintf(`%s%s`, cachePrefixTableFields, c.db.GetGroup())
-		removedKeys = make([]string, 0)
+		keys, _     = c.innerMemCache.KeyStrings(ctx)
+		cachePrefix = cachePrefixTableFields
+		removedKeys = make([]any, 0)
+	)
+	for _, key := range keys {
+		if gstr.HasPrefix(key, cachePrefix) {
+			removedKeys = append(removedKeys, key)
+		}
+	}
+
+	if len(removedKeys) > 0 {
+		err = c.innerMemCache.Removes(ctx, removedKeys)
+	}
+	return
+}
+
+// ClearCache removes cached sql result of certain table.
+func (c *Core) ClearCache(ctx context.Context, table string) (err error) {
+	var (
+		keys, _     = c.db.GetCache().KeyStrings(ctx)
+		cachePrefix = fmt.Sprintf(`%s%s@`, cachePrefixSelectCache, table)
+		removedKeys = make([]any, 0)
 	)
 	for _, key := range keys {
 		if gstr.HasPrefix(key, cachePrefix) {
@@ -167,32 +183,20 @@ func (c *Core) ClearTableFieldsAll(ctx context.Context) (err error) {
 		}
 	}
 	if len(removedKeys) > 0 {
-		tableFieldsMap.Removes(removedKeys)
+		err = c.db.GetCache().Removes(ctx, removedKeys)
 	}
 	return
 }
 
-// ClearCache removes cached sql result of certain table.
-func (c *Core) ClearCache(ctx context.Context, table string) (err error) {
-	return c.db.GetCache().Clear(ctx)
-}
-
 // ClearCacheAll removes all cached sql result from cache
 func (c *Core) ClearCacheAll(ctx context.Context) (err error) {
-	return c.db.GetCache().Clear(ctx)
-}
-
-func (c *Core) makeSelectCacheKey(name, schema, table, sql string, args ...interface{}) string {
-	if name == "" {
-		name = fmt.Sprintf(
-			`%s@%s#%s:%s`,
-			c.db.GetGroup(),
-			schema,
-			table,
-			gmd5.MustEncryptString(sql+", @PARAMS:"+gconv.String(args)),
-		)
+	if err = c.db.GetCache().Clear(ctx); err != nil {
+		return err
 	}
-	return fmt.Sprintf(`%s%s`, cachePrefixSelectCache, name)
+	if err = c.GetInnerMemCache().Clear(ctx); err != nil {
+		return err
+	}
+	return
 }
 
 // HasField determine whether the field exists in the table.

database/gdb/gdb_driver_wrapper_db.go

@@ -11,10 +11,12 @@ import (
 	"database/sql"
 	"fmt"
 
+	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/internal/intlog"
+	"github.com/gogf/gf/v2/os/gcache"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gutil"
 )
@@ -68,25 +70,29 @@ func (d *DriverWrapperDB) TableFields(
 		)
 	}
 	var (
+		innerMemCache = d.GetCore().GetInnerMemCache()
 		// prefix:group@schema#table
-		cacheKey = fmt.Sprintf(
-			`%s%s@%s#%s`,
-			cachePrefixTableFields,
+		cacheKey = genTableFieldsCacheKey(
 			d.GetGroup(),
 			gutil.GetOrDefaultStr(d.GetSchema(), schema...),
 			table,
 		)
-		value = tableFieldsMap.GetOrSetFuncLock(cacheKey, func() interface{} {
-			ctx = context.WithValue(ctx, ctxKeyInternalProducedSQL, struct{}{})
-			fields, err = d.DB.TableFields(ctx, table, schema...)
-			if err != nil {
-				return nil
-			}
-			return fields
-		})
+		cacheFunc = func(ctx context.Context) (interface{}, error) {
+			return d.DB.TableFields(
+				context.WithValue(ctx, ctxKeyInternalProducedSQL, struct{}{}),
+				table, schema...,
 			)
-	if value != nil {
-		fields = value.(map[string]*TableField)
+		}
+		value *gvar.Var
+	)
+	value, err = innerMemCache.GetOrSetFuncLock(
+		ctx, cacheKey, cacheFunc, gcache.DurationNoExpire,
+	)
+	if err != nil {
+		return
+	}
+	if !value.IsNil() {
+		fields = value.Val().(map[string]*TableField)
 	}
 	return
 }

database/gdb/gdb_func.go

@@ -16,6 +16,7 @@ import (
 	"time"
 
 	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/encoding/ghash"
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/intlog"
@@ -944,3 +945,26 @@ func FormatMultiLineSqlToSingle(sql string) (string, error) {
 	}
 	return sql, nil
 }
+
+func genTableFieldsCacheKey(group, schema, table string) string {
+	return fmt.Sprintf(
+		`%s%s@%s#%s`,
+		cachePrefixTableFields,
+		group,
+		schema,
+		table,
+	)
+}
+
+func genSelectCacheKey(table, group, schema, name, sql string, args ...interface{}) string {
+	if name == "" {
+		name = fmt.Sprintf(
+			`%s@%s#%s:%d`,
+			table,
+			group,
+			schema,
+			ghash.BKDR64([]byte(sql+", @PARAMS:"+gconv.String(args))),
+		)
+	}
+	return fmt.Sprintf(`%s%s`, cachePrefixSelectCache, name)
+}

database/gdb/gdb_model_cache.go

@@ -142,10 +142,17 @@ func (m *Model) saveSelectResultToCache(
 }
 
 func (m *Model) makeSelectCacheKey(sql string, args ...interface{}) string {
-	return m.db.GetCore().makeSelectCacheKey(
-		m.cacheOption.Name,
-		m.db.GetSchema(),
-		m.db.GetCore().guessPrimaryTableName(m.tables),
+	var (
+		table      = m.db.GetCore().guessPrimaryTableName(m.tables)
+		group      = m.db.GetGroup()
+		schema     = m.db.GetSchema()
+		customName = m.cacheOption.Name
+	)
+	return genSelectCacheKey(
+		table,
+		group,
+		schema,
+		customName,
 		sql,
 		args...,
 	)

database/gdb/gdb_model_soft_time.go

@@ -190,12 +190,21 @@ func (m *softTimeMaintainer) getSoftFieldNameAndType(
 	schema string, table string, checkFiledNames []string,
 ) (fieldName string, fieldType LocalType) {
 	var (
-		cacheKey      = fmt.Sprintf(`getSoftFieldNameAndType:%s#%s#%s`, schema, table, strings.Join(checkFiledNames, "_"))
+		innerMemCache = m.db.GetCore().GetInnerMemCache()
+		cacheKey      = fmt.Sprintf(
+			`getSoftFieldNameAndType:%s#%s#%s`,
+			schema, table, strings.Join(checkFiledNames, "_"),
+		)
 		cacheDuration = gcache.DurationNoExpire
 		cacheFunc     = func(ctx context.Context) (value interface{}, err error) {
 			// Ignore the error from TableFields.
-			fieldsMap, _ := m.TableFields(table, schema)
-			if len(fieldsMap) > 0 {
+			fieldsMap, err := m.TableFields(table, schema)
+			if err != nil {
+				return nil, err
+			}
+			if len(fieldsMap) == 0 {
+				return nil, nil
+			}
 			for _, checkFiledName := range checkFiledNames {
 				fieldName, _ = gutil.MapPossibleItemByKey(
 					gconv.Map(fieldsMap), checkFiledName,
@@ -211,22 +220,21 @@ func (m *softTimeMaintainer) getSoftFieldNameAndType(
 					return cacheItem, nil
 				}
 			}
-			}
 			return
 		}
 	)
-	result, err := gcache.GetOrSetFunc(ctx, cacheKey, cacheFunc, cacheDuration)
+	result, err := innerMemCache.GetOrSetFunc(
+		ctx, cacheKey, cacheFunc, cacheDuration,
+	)
 	if err != nil {
-		intlog.Error(ctx, err)
+		return
 	}
-	if result != nil {
-		var cacheItem getSoftFieldNameAndTypeCacheItem
-		if err = result.Scan(&cacheItem); err != nil {
-			return "", ""
+	if result == nil {
+		return
 	}
+	cacheItem := result.Val().(getSoftFieldNameAndTypeCacheItem)
 	fieldName = cacheItem.FieldName
 	fieldType = cacheItem.FieldType
-	}
 	return
 }
 

net/ghttp/ghttp_server.go

@@ -569,10 +569,15 @@ func (s *Server) startServer(fdMap listenerFdMap) {
 	}
 	// Start listening asynchronously.
 	serverRunning.Add(1)
-	var wg = sync.WaitGroup{}
-	for _, v := range s.servers {
+	var wg = &sync.WaitGroup{}
+	for _, gs := range s.servers {
 		wg.Add(1)
-		go func(server *gracefulServer) {
+		go s.startGracefulServer(ctx, wg, gs)
+	}
+	wg.Wait()
+}
+
+func (s *Server) startGracefulServer(ctx context.Context, wg *sync.WaitGroup, server *gracefulServer) {
 	s.serverCount.Add(1)
 	var err error
 	// Create listener.
@@ -601,9 +606,6 @@ func (s *Server) startServer(fdMap listenerFdMap) {
 			allShutdownChan <- struct{}{}
 		}
 	}
-		}(v)
-	}
-	wg.Wait()
 }
 
 // Status retrieves and returns the server status.

os/gfsnotify/gfsnotify.go

@@ -96,8 +96,8 @@ func New() (*Watcher, error) {
 		intlog.Printf(context.TODO(), "New watcher failed: %v", err)
 		return nil, err
 	}
-	w.watchLoop()
-	w.eventLoop()
+	go w.watchLoop()
+	go w.eventLoop()
 	return w, nil
 }
 

os/gfsnotify/gfsnotify_watcher_loop.go

@@ -18,7 +18,6 @@ import (
 
 // watchLoop starts the loop for event listening from underlying inotify monitor.
 func (w *Watcher) watchLoop() {
-	go func() {
 	for {
 		select {
 		// Close event.
@@ -52,12 +51,10 @@ func (w *Watcher) watchLoop() {
 			intlog.Errorf(context.TODO(), `%+v`, err)
 		}
 	}
-	}()
 }
 
 // eventLoop is the core event handler.
 func (w *Watcher) eventLoop() {
-	go func() {
 	for {
 		if v := w.events.Pop(); v != nil {
 			event := v.(*Event)
@@ -147,7 +144,6 @@ func (w *Watcher) eventLoop() {
 			break
 		}
 	}
-	}()
 }
 
 // getCallbacks searches and returns all callbacks with given `path`.

os/grpool/grpool_pool.go

@@ -99,7 +99,10 @@ func (p *Pool) checkAndForkNewGoroutineWorker() {
 	}
 
 	// Create job function in goroutine.
-	go func() {
+	go p.asynchronousWorker()
+}
+
+func (p *Pool) asynchronousWorker() {
 	defer p.count.Add(-1)
 
 	var (
@@ -115,5 +118,4 @@ func (p *Pool) checkAndForkNewGoroutineWorker() {
 		poolItem = listItem.(*localPoolItem)
 		poolItem.Func(poolItem.Ctx)
 	}
-	}()
 }

os/gtimer/gtimer_entry.go

@@ -8,6 +8,7 @@ package gtimer
 
 import (
 	"context"
+
 	"github.com/gogf/gf/v2/errors/gcode"
 
 	"github.com/gogf/gf/v2/container/gtype"
@@ -45,7 +46,11 @@ func (entry *Entry) Run() {
 			return
 		}
 	}
-	go func() {
+	go entry.callJobFunc()
+}
+
+// callJobFunc executes the job function in entry.
+func (entry *Entry) callJobFunc() {
 	defer func() {
 		if exception := recover(); exception != nil {
 			if exception != panicExit {
@@ -64,7 +69,6 @@ func (entry *Entry) Run() {
 		}
 	}()
 	entry.job(entry.ctx)
-	}()
 }
 
 // doCheckAndRunByTicks checks the if job can run in given timer ticks,

os/gtimer/gtimer_timer_loop.go

@@ -10,7 +10,6 @@ import "time"
 
 // loop starts the ticker using a standalone goroutine.
 func (t *Timer) loop() {
-	go func() {
 	var (
 		currentTimerTicks   int64
 		timerIntervalTicker = time.NewTicker(t.options.Interval)
@@ -36,14 +35,11 @@ func (t *Timer) loop() {
 			}
 		}
 	}
-	}()
 }
 
 // proceed function proceeds the timer job checking and running logic.
 func (t *Timer) proceed(currentTimerTicks int64) {
-	var (
-		value interface{}
-	)
+	var value interface{}
 	for {
 		value = t.queue.Pop()
 		if value == nil {