github.com/zartbot/goflow@v0.0.0-20221001080520-456f7dfad288/lib/ksyncmap/ksyncmap.go (about)

     1  //Package ksyncmap : a timeout based syncmap
     2  package ksyncmap
     3  
     4  import (
     5  	"fmt"
     6  	"math/rand"
     7  	"reflect"
     8  	"sync"
     9  	"time"
    10  )
    11  
    12  //KSyncMap is the main struct of timeout based syncmap
    13  //Data : data syncmap.
    14  //Timeout : Timeout value
    15  //UpdateTimestamp store last updatetime, and avoid datamap update freq.
    16  type Map struct {
    17  	Name       string
    18  	Data       sync.Map
    19  	Timeout    int64
    20  	CheckFreq  int64
    21  	ExpireTime sync.Map
    22  	Verbose    bool
    23  }
    24  
    25  func NewMap(name string, timeout int64, checkfreq int64, verbose bool) *Map {
    26  	return &Map{
    27  		Name:      name,
    28  		Timeout:   timeout,
    29  		CheckFreq: checkfreq,
    30  		Verbose:   verbose,
    31  	}
    32  }
    33  
    34  func (k *Map) Load(key interface{}) (value interface{}, ok bool) {
    35  	return k.Data.Load(key)
    36  }
    37  
    38  func (k *Map) Store(key interface{}, value interface{}, currentTime time.Time) {
    39  	//Check ExpireTime Map.
    40  	exp, ok := k.ExpireTime.Load(key)
    41  	if !ok {
    42  		expireTime := currentTime.Add(time.Duration(k.Timeout) * time.Second)
    43  		k.ExpireTime.Store(key, expireTime)
    44  	} else {
    45  		elapsed := exp.(time.Time).Sub(currentTime)
    46  		//elapsed time less than half of timeout, update ExpireTime Store.
    47  		if elapsed < time.Duration(k.Timeout/2) {
    48  			expireTime := currentTime.Add(time.Duration(k.Timeout) * time.Second)
    49  			k.ExpireTime.Store(key, expireTime)
    50  		}
    51  	}
    52  	k.Data.Store(key, value)
    53  }
    54  
    55  func (k *Map) UpdateTime(key interface{}, currentTime time.Time) {
    56  	expireTime := currentTime.Add(time.Duration(k.Timeout) * time.Second)
    57  	k.ExpireTime.Store(key, expireTime)
    58  }
    59  
    60  func (k *Map) Delete(key interface{}) {
    61  	k.Data.Delete(key)
    62  	k.ExpireTime.Delete(key)
    63  }
    64  
    65  func (k *Map) Run() {
    66  	rand.Seed(time.Now().UnixNano())
    67  	r := k.CheckFreq / 5
    68  	for {
    69  		currentTime := time.Now()
    70  		k.ExpireTime.Range(func(key, v interface{}) bool {
    71  			value := v.(time.Time)
    72  			if value.Sub(currentTime) < 0 {
    73  				//fmt.Println("DEBUG:::DELETE-KEY", reflect.ValueOf(key))
    74  				k.Data.Delete(key)
    75  				k.ExpireTime.Delete(key)
    76  			}
    77  			return true
    78  		})
    79  		if k.Verbose {
    80  			k.ShowExpireTime()
    81  			k.ShowData()
    82  		}
    83  		time.Sleep(time.Second * time.Duration(k.CheckFreq+rand.Int63n(r)))
    84  	}
    85  }
    86  
    87  func (k *Map) ShowExpireTime() {
    88  	fmt.Printf("%10s:--------------------Expire Time Table-------------------------------\n", k.Name)
    89  	i := 1
    90  	k.ExpireTime.Range(func(kt, v interface{}) bool {
    91  		value := v.(time.Time)
    92  		key := reflect.ValueOf(kt)
    93  		fmt.Printf("%10s:[%6d]Key:%v | ExipreTime: %v \n", k.Name, i, key, value)
    94  		i++
    95  		return true
    96  	})
    97  	fmt.Printf("%10s:--------------------------------------------------------------------\n\n", k.Name)
    98  }
    99  
   100  func (k *Map) ShowData() {
   101  	fmt.Printf("%10s:---------------------Data Table-------------------------------------\n", k.Name)
   102  	i := 1
   103  	k.Data.Range(func(kt, v interface{}) bool {
   104  		value := reflect.ValueOf(v)
   105  		key := reflect.ValueOf(kt)
   106  		fmt.Printf("%10s:[%6d]Key:%v | Value: %v \n", k.Name, i, key, value)
   107  		i++
   108  		return true
   109  	})
   110  	fmt.Printf("%10s:--------------------------------------------------------------------\n\n", k.Name)
   111  }