Study on the example of Golang implementing EasyCache cache library

func New(conf Config) (*EasyCache, error) {

	if !() {
		returnnil, ("shards number must be power of two")
	}

	if  <= 0 {
		 = defaultCap
	}
	// init cache object
	cache := &EasyCache{
		shards:    make([]*cacheShard, ),
		conf:      conf,
		hash:      ,
		shardMask: uint64( - 1), // mask
		close:     make(chanstruct{}),
	}

	var onRemove OnRemoveCallback
	if  != nil {
		onRemove = 
	} else {
		onRemove = 
	}

	// init shard
	for i := 0; i < ; i++ {
		[i] = newCacheShard(conf, i, onRemove, )
	}
	return cache, nil
}

func newCacheShard(conf Config, id int, onRemove OnRemoveCallback, close chan struct{}) *cacheShard {
	shard := &cacheShard{
		items:           make(map[string]*),
		expireItems:     make(map[string]*),
		cap:             ,
		list:            (),
		logger:          newLogger(),
		cleanupInterval: defaultInternal,
		cleanupTicker:   (defaultInternal),
		addChan:         make(chanstring),
		isVerbose:       ,
		id:              id,
		onRemove:        onRemove,
		close:           close,
	}
	// goroutine clean expired key
	go ()
	return shard
}

/*
 1. When the timer expires, perform expired cleaning.
 2. When the newly added key has an expiration time, the execution is triggered by addChan
 */
func (cs *cacheShard) expireCleanup() {
	for {
		select {
		case <-:
		case <-: // Trigger immediately		case <-: // stop goroutine
			if  {
				("[shard %d] flush..", )
			}
			() // free
			return
		}
		()
		// Record the minimum interval of the next timer (purpose: the key expires, delete it as soon as possible)		smallestInternal := 0 * 
		now := ()
		()
		for key, ele := range  { // traverse expired keys			item := .(*cacheItem)
			if () == 0 { // No expiration time				("warning wrong data\n")
				continue
			}
			if (()) >= () { // Expired				// del
				delete(, key)
				delete(, key)
				(ele)
				(key, (), Expired)
				if  {
					("[shard %d]: expire del key <%s>  createdOn:%v,  lifeSpan:%d ms \n", , key, (), ().Milliseconds())
				}
			} else {
				d := () - (())
				if smallestInternal == 0 || d < smallestInternal {
					smallestInternal = d
				}
			}
		}
		if smallestInternal == 0 {
			smallestInternal = defaultInternal
		}
		 = smallestInternal
		()
		()
	}
}

(key, 0, 5*) // expire 5s
(key, 0, 0*) // expire 0s

func (cs *cacheShard) set(key string, value interface{}, lifeSpan ) error {

	()
	defer ()

	oldEle, ok := [key]
	if ok { // old item
		oldItem := .(*cacheItem)
		oldLifeSpan := ()

		// modify
		 = newCacheItem(key, value, lifeSpan)
		(oldEle)

		if oldLifeSpan > 0 && lifeSpan == 0 { // The original one has an expiration time, the new one has no expiration time			delete(, key)
		}

		if oldLifeSpan == 0 && lifeSpan > 0 { // The original no expiration time, the current expiration time			[key] = oldEle
			if lifeSpan <  {
				gofunc() {
					 <- key
				}()
			}
		}

	} else { // new item

		iflen() >= int() { // lru: No space
			delVal := (())
			item := delVal.(*cacheItem)
			delete(, ())
			if () > 0 {
				delete(, ())
			}
			(key, (), NoSpace)

			if  {
				("[shard %d] no space del key <%s>\n", , ())
			}
		}
		// add
		ele := (newCacheItem(key, value, lifeSpan))
		[key] = ele
		if lifeSpan > 0 {
			[key] = ele
			if lifeSpan <  {
				gofunc() {
					 <- key
				}()
			}
		}
	}

	if  {
		if lifeSpan == 0 {
			("[shard %d]: set persist key <%s>\n", , key)
		} else {
			("[shard %d]: set expired key <%s>", , key)
		}
	}
	returnnil
}