Add mutex for protect Context.Keys map

[AcoNCodes]

We get a panic in a loaded project related with use c.Get / c.Set in many middleware routines.

[codecov]

Codecov Report

Merging #1391 into master will increase coverage by 0.00%.
The diff coverage is 100.00%.

@@           Coverage Diff           @@
##           master    #1391   +/-   ##
=======================================
  Coverage   98.47%   98.47%           
=======================================
  Files          41       41           
  Lines        2293     2298    +5     
=======================================
+ Hits         2258     2263    +5     
  Misses         20       20           
  Partials       15       15           

Impacted Files	Coverage Δ
context.go	98.06% <100.00%> (+0.02%)	⬆️
gin.go	99.13% <100.00%> (ø)

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 67008be...b1d9b1a. Read the comment docs.

[thinkerou]

Hi @AcoNCodes alike pull request have #702 and issue #700

[night-codes]

@thinkerou this solution more lightweight, focused and without conflicts. The problem exists and forces me to use a fork that does not contain the latest updates. I'm looking forward to solve the problem.

[thinkerou]

@night-codes thanks, I don't have any advice, the feature need @javierprovecho and @appleboy agree.

[duyanghao]

any update for this pr?

[appleboy]

@AcoNCodes Please fix the conflicts.

[thinkerou]

@AcoNCodes why not use sync.Map? thanks!

[appleboy]

@thinkerou Performance: sync.Mutex > sync.Map for multiple reads and writes.

var s sync.RWMutex
var w sync.WaitGroup

func main() {
	mapTest()
	syncMapTest()
}
func mapTest() {
	m := map[int]int {1:1}
	startTime := time.Now().Nanosecond()
	w.Add(1)
	go writeMap(m)
	w.Add(1)
	go writeMap(m)

	w.Wait()
	endTime := time.Now().Nanosecond()
	timeDiff := endTime-startTime
	fmt.Println("map:",timeDiff)
}

func writeMap (m map[int]int) {
	defer w.Done()
	i := 0
	for i < 10000 {
		s.Lock()
		m[1]=1
		s.Unlock()
		i++
	}
}

func readMap (m map[int]int) {
	defer w.Done()
	i := 0
	for i < 10000 {
		s.RLock()
		_ = m[1]
		s.RUnlock()
		i++
	}
}

func syncMapTest() {
	m := sync.Map{}
	m.Store(1,1)
	startTime := time.Now().Nanosecond()
	w.Add(1)
	go writeSyncMap(m)
	w.Add(1)
	go writeSyncMap(m)

	w.Wait()
	endTime := time.Now().Nanosecond()
	timeDiff := endTime-startTime
	fmt.Println("sync.Map:",timeDiff)
}

func writeSyncMap (m sync.Map) {
	defer w.Done()
	i := 0
	for i < 10000 {
		m.Store(1,1)
		i++
	}
}

func readSyncMap (m sync.Map) {
	defer w.Done()
	i := 0
	for i < 10000 {
		m.Load(1)
		i++
	}
}

[appleboy]

@AcoNCodes The PR trigger the performance issue in #2350

[thinkerou]

We get a panic in a loaded project related with use c.Get / c.Set in many middleware routines.

add a switch to open/close the feature? @appleboy

[appleboy]

See #2351 I add new variable to enable/disable the mutex for protecting Context.Keys map (default as false) and also fix the comment.