updatecache

README

updatecache

Overview

The purpose of updatecache is to update the cache conveniently.

Feature

• prevent cache breakdown
• perform regular update of the cache
• limit the frequency of access to the upstream(single flight)

Install

go get github.com/vearne/updatecache

Usage

use NewCache to create a local cache.

NewCache(waitUpdate bool, opts ...Option) *LocalCache

waitUpdate

when the Get() is called

(c *LocalCache) Get(key any) any

• true: If the value corresponding to a key is being updated, wait for the update function to complete and obtain the latest value
• false: If the value corresponding to a key is being updated, just use previous value.

opts

WithRateLimit create a Limiter to Limit the execution frequency of get value from upstream.

WithRateLimit(r float64, b int) Option

c := cache.NewCache(true, cache.WithRateLimit(200, 1))

Use environment variables to set log level

optional value: debug | info | warn | error

export SIMPLE_LOG_LEVEL=debug

Unit Test

go test .
go test -v .
go test -run TestFirstLoad ./

Example

package main

import (
	cache "github.com/vearne/updatecache"
	"log"
	"sync/atomic"
	"time"
)

func calcuDuration(value any) time.Duration {
	return time.Second
}

func main() {
	key := "aaa"
	c := cache.NewCache(true, cache.WithRateLimit(200, 1))
	var counter uint32 = 2
	if !c.Contains(key) {
		result := c.FirstLoad(key,
			1,
			func() (any, error) {
				time.Sleep(time.Second)
				log.Println("FirstLoad-GetValueFunc")
				return 2, nil
			},
			10*time.Second)
		c.DynamicUpdateLater(key, calcuDuration, func() (any, error) {
			// get value from backend(for example: MySQL, MongoDB or other application)
			log.Println("get value from backend...")
			return atomic.AddUint32(&counter, 1), nil
		})
		log.Printf("result:%v \n", result)
	}
	for i := 0; i < 30; i++ {
		time.Sleep(500 * time.Millisecond)
		log.Println(c.Get(key))
	}
}

Documentation

Index

• type CalcTimeForNextUpdateFunc
• type GetValueFunc
• type Item
  • func NewItem(key, value any) *Item
• type LocalCache
  • func NewCache(waitUpdate bool, opts ...Option) *LocalCache
  • func (c *LocalCache) Contains(key any) (ok bool)
  • func (c *LocalCache) DynamicUpdateLater(key any, cf CalcTimeForNextUpdateFunc, gf GetValueFunc)
  • func (c *LocalCache) FirstLoad(key any, defaultValue any, gf GetValueFunc, d time.Duration) any
  • func (c *LocalCache) Get(key any) any
  • func (c *LocalCache) Remove(key any)
  • func (c *LocalCache) Set(key any, value any, d time.Duration)
  • func (c *LocalCache) SetIfNotExist(key any, value any, d time.Duration)
  • func (c *LocalCache) Size() int
  • func (c *LocalCache) Stop()
  • func (c *LocalCache) StopLaterUpdate(key any)
• type Option
  • func WithRateLimit(r float64, b int) Option

Types

type CalcTimeForNextUpdateFunc

type CalcTimeForNextUpdateFunc func(value any) time.Duration

Calculate the waiting time until the next data update

type GetValueFunc

type GetValueFunc func() (value any, err error)

type Item

type Item struct {
	// contains filtered or unexported fields
}

func NewItem

func NewItem(key, value any) *Item

type LocalCache

type LocalCache struct {
	// contains filtered or unexported fields
}

func NewCache

func NewCache(waitUpdate bool, opts ...Option) *LocalCache

func (*LocalCache) Contains

func (c *LocalCache) Contains(key any) (ok bool)

func (*LocalCache) DynamicUpdateLater

func (c *LocalCache) DynamicUpdateLater(key any, cf CalcTimeForNextUpdateFunc, gf GetValueFunc)

Notice: Item and CalcTimeForNextUpdateFunc, GetValueFunc will only be bound once. 1. Calculate the waiting time until the next data update with CalcTimeForNextUpdateFunc 2. then use GetValueFunc to get value 3. update item

func (*LocalCache) FirstLoad

func (c *LocalCache) FirstLoad(key any, defaultValue any, gf GetValueFunc, d time.Duration) any

func (*LocalCache) Get

func (c *LocalCache) Get(key any) any

func (*LocalCache) Remove

func (c *LocalCache) Remove(key any)

func (*LocalCache) Set

func (c *LocalCache) Set(key any, value any, d time.Duration)

If d is less than 0, the item does not expire

func (*LocalCache) SetIfNotExist

func (c *LocalCache) SetIfNotExist(key any, value any, d time.Duration)

If d is less than 0, the item does not expire

func (*LocalCache) Size

func (c *LocalCache) Size() int

func (*LocalCache) Stop

func (c *LocalCache) Stop()

func (*LocalCache) StopLaterUpdate

func (c *LocalCache) StopLaterUpdate(key any)

type Option

type Option func(cache *LocalCache)

func WithRateLimit

func WithRateLimit(r float64, b int) Option

WithRateLimit create a new Limiter that allows events up to rate r and permits bursts of at most b tokens. rate limiter Limit the execution frequency of GetValueFunc