package cache

import (

	"container/list"

	"sync"

)

// entry 存储的实体

type entry struct {

	key, val interface{}

}

// Cache 缓存结构

type Cache struct {

	// m 保证 LRU Cache 访问线程安全

	rw sync.RWMutex

	// max 标识缓存容量的最大值, = 0 标识无限缓存

	max int

	// list 是 entry 循环双向链表

	list *list.List

	// pond entry 缓存池子 key -> entry

	pond map[interface{}]*list.Element

}

// New 构建 LRU Cache 缓存结构

func New(max int) *Cache {

	return &Cache{

		max:  max,

		list: list.New(),

		pond: make(map[interface{}]*list.Element),

	}

}

func (c *Cache) delete(key interface{}) {

	element, ok := c.pond[key]

	if ok {

		delete(c.pond, key)

		c.list.Remove(element)

		return

	}

}

// Set 设置缓存

func (c *Cache) Set(key, val interface{}) {

	c.rw.Lock()

	defer c.rw.Unlock()

	// 看是否进入删除分支

	if val == nil {

		c.delete(key)

		return

	}

	element, ok := c.pond[key]

	if ok {

		// 重新设置 value 数据

		element.Value.(*entry).val = val

		// set key nil exists 进入 update 逻辑

		c.list.MoveToFront(element)

		return

	}

	// 首次添加

	c.pond[key] = c.list.PushFront(&entry{key, val})

	// 数据过多, 删除尾巴数据

	if c.list.Len() > c.max && c.max > 0 {

		delete(c.pond, c.list.Remove(c.list.Back()).(*entry).key)

	}

}

// Get 获取缓存

func (c *Cache) Get(key interface{}) (val interface{}, ok bool) {

	c.rw.RLock()

	defer c.rw.RUnlock()

	if element, ok := c.pond[key]; ok {

		// 获取指定缓存值

		val, ok = element.Value.(*entry).val, true

		// 调整缓存热点

		c.list.MoveToFront(element)

	}

	return

}

// 创建

c := cache.New(1)

// 设置

c.Set("123", "123")

c.Set("234", "234")

// 使用

fmt.Println(c.Get("123"))

fmt.Println(c.Get("234"))

// 删除

c.Set("123", nil)

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Package list implements a doubly linked list.

//

// To iterate over a list (where l is a *List):

//    for e := l.Front(); e != nil; e = e.Next() {

//        // do something with e.Value

//    }

//

package list

// Element is an element of a linked list.

type Element struct {

    // Next and previous pointers in the doubly-linked list of elements.

    // To simplify the implementation, internally a list l is implemented

    // as a ring, such that &l.root is both the next element of the last

    // list element (l.Back()) and the previous element of the first list

    // element (l.Front()).

    next, prev *Element

    // The list to which this element belongs.

    list *List

    // The value stored with this element.

    Value interface{}

}

// Next returns the next list element or nil.

func (e *Element) Next() *Element {

    if p := e.next; e.list != nil && p != &e.list.root {

        return p

    }

    return nil

}

// Prev returns the previous list element or nil.

func (e *Element) Prev() *Element {

    if p := e.prev; e.list != nil && p != &e.list.root {

        return p

    }

    return nil

}

// List represents a doubly linked list.

// The zero value for List is an empty list ready to use.

type List struct {

    root Element // sentinel list element, only &root, root.prev, and root.next are used

    len  int     // current list length excluding (this) sentinel element

}

func Test_List_Demo(t *testing.T) {

    // Persion 普通人

    type Persion struct {

        Name string

        Age  int

    }

    pers := list.New()

    // 链表数据填充

    pers.PushBack(&Persion{Name: "wang", Age: 31})

    pers.PushFront(&Persion{Name: "zhi", Age: 31})

    fmt.Printf("List Len() = %d\n", pers.Len())

    if pers.Len() != 2 {

        t.Fatal("pers.Len() != 2 data faild")

    }

    // 开始遍历数据

    for element := pers.Front(); element != nil; element = element.Next() {

        per, ok := element.Value.(*Persion)

        if !ok {

            panic(fmt.Sprint("Persion list faild", element.Value))

        }

        fmt.Println(per)

    }

    // 数据删除

    for element := pers.Front(); element != nil; {

        next := element.Next()

        pers.Remove(element)

        element = next

    }

    fmt.Printf("List Len() = %d\n", pers.Len())

    if pers.Len() != 0 {

        t.Fatal("pers.Len() != 0 data faild")

    }

}

Running tool: /usr/local/go/bin/go test -timeout 30s -run ^Test_List_Demo$ demo/src/container/list -v -count=1

=== RUN   Test_List_Demo

List Len() = 2

&{zhi 31}

&{wang 31}

List Len() = 0

--- PASS: Test_List_Demo (0.00s)

PASS

ok      demo/src/container/list    0.002s

//

// src/net/http/transport.go

//

// persistConn wraps a connection, usually a persistent one

// (but may be used for non-keep-alive requests as well)

type persistConn struct {

　　... 
　　.. 
　　.

}

type connLRU struct {

    ll *list.List // list.Element.Value type is of *persistConn

    m  map[*persistConn]*list.Element

}

// add adds pc to the head of the linked list.

func (cl *connLRU) add(pc *persistConn) {

    if cl.ll == nil {

        cl.ll = list.New()

        cl.m = make(map[*persistConn]*list.Element)

    }

    ele := cl.ll.PushFront(pc)

    if _, ok := cl.m[pc]; ok {

        panic("persistConn was already in LRU")

    }

    cl.m[pc] = ele

}

func (cl *connLRU) removeOldest() *persistConn {

    ele := cl.ll.Back()

    pc := ele.Value.(*persistConn)

    cl.ll.Remove(ele)

    delete(cl.m, pc)

    return pc

}

// remove removes pc from cl.

func (cl *connLRU) remove(pc *persistConn) {

    if ele, ok := cl.m[pc]; ok {

        cl.ll.Remove(ele)

        delete(cl.m, pc)

    }

}

// len returns the number of items in the cache.

func (cl *connLRU) len() int {

    return len(cl.m)

}