1
2
3
4
5

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.70</version>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

{
  "properties": {
    "jobName": "this_is_a_test",
    "description": "for test json"
  },
  "task": [
    {
      "name": "task_1",
      "type": "test",
      "className": "com.jjmeg.Task",
      "args": {
        "topic": "mockTopic",
        "username": "mockPin",
        "password": "mockPasswd"
      }
    }
  ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class Flow {
    public Map<String, String> properties;
    public List<Task> task;

    @Override
    public String toString() {
        return "Flow{" +
                "properties='" + properties + '\'' +
                ", task='" + task +'\'' +
                '}';
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class Task implements Serializable {
    public String name;

    public String type;

    public String className;

    public Map<String, String> args;

    // 含参构造函数、无默认构造函数
    public Task(String name) {
        this.name = name;
    }

    public static void main(String[] args) throws ConfigurationException, IOException {
        String text = IOUtils.toString(new FileInputStream(filePath), StandardCharsets.UTF_8);
        Flow flow = JSON.parseObject(text, Flow.class);
    }
}

1

Task{name='task_1', type='null', className='null', args=null}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 无参函数
public Task() {
}

// 含所有参数的构造函数
public Task(String name, String className, String type, Map<String, String> args) {
    this.name = name;
    this.args = args;
    this.type = type;
    this.className = className;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

package reporter

import (
	"github.com/Shopify/sarama"
	"github.com/sirupsen/logrus"

	"../error_const"
)

// kafka server 端配置
type KafkaCfg struct {
	Host  string `json:"host"`
	Topic string `json:"topic"`
}

// 消息生产者数据结构
type Reporter struct {
	Producer sarama.SyncProducer
	logger   *logrus.Logger
}

// 构造函数
func NewReporter(cfg *KafkaCfg, log *logrus.Logger) *Reporter {
	reporter := &Reporter{
		logger: log,
	}

	reporter.setProducer(cfg)
	return reporter
}

func (reporter *Reporter) setProducer(cfg *KafkaCfg) {
	var broker = []string{cfg.Host}

	config := sarama.NewConfig()
	config.Producer.Return.Successes = true
	// new 一个Producer
	producer, err := sarama.NewSyncProducer(broker, config)
	if err != nil {
		reporter.logger.Errorf(error_const.InitProducerError, err)
	}

	reporter.Producer = producer
}

func (reporter *Reporter) DoReport(topic string, msg []byte) {
	reporter.do(topic, msg)
}

func (reporter *Reporter) do(topic string, msg []byte) {
	kafkaMsg := generateProducerMessage(topic, msg)
	_, _, err := reporter.Producer.SendMessage(kafkaMsg)
	if err != nil {
		reporter.logger.Errorf(error_const.ReportKafkaMsgError, err, string(msg))
	}
	reporter.logger.Infof(error_const.ReportKafkaMsgSuccess, string(msg))
}

func generateProducerMessage(topic string, message []byte) *sarama.ProducerMessage {
	return &sarama.ProducerMessage{
		Topic:     topic,
		Partition: -1,
		Value:     sarama.StringEncoder(message),
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

package subscriber

import (
	"github.com/Shopify/sarama"
	"github.com/sirupsen/logrus"

	"../error_const"
	"../reporter"
)

type Subscriber struct {
	Consumer sarama.Consumer
	logger   *logrus.Logger
}

func NewSubscriber(cfg *reporter.KafkaCfg, log *logrus.Logger) *Subscriber {
	subscriber := &Subscriber{
		logger: log,
	}
	subscriber.setConsumer(cfg)
	return subscriber
}

func (subscriber *Subscriber) setConsumer(cfg *reporter.KafkaCfg) {
	consumer, err := sarama.NewConsumer([]string{cfg.Host}, nil)
	if err != nil {
		panic(err)
	}
	subscriber.Consumer = consumer
}

func (subscriber *Subscriber) Consume(topic string, ch chan string) {
	defer func() {
		if err := subscriber.Consumer.Close(); err != nil {
			subscriber.logger.Errorf(error_const.SubcriberCloseConsumerError, err)
		}
	}()

	// 获取所有 partition
	partitionList, err := subscriber.Consumer.Partitions(topic)
	if err != nil {
		subscriber.logger.Errorf(error_const.SubScriberGetPartitionsError, err, topic)
	}

	// 遍历所有 partition 获取最新 offset 上的消息
	for _, partition := range partitionList {
		pc, _ := subscriber.Consumer.ConsumePartition(topic, partition, sarama.OffsetNewest)
  	// 启动一个 goroutine 用于持续监听消息
		go func(pc sarama.PartitionConsumer) {
			for message := range pc.Messages() {
				subscriber.logger.Infof(messageReceived(message))
				ch <- messageReceived(message)
			}
		}(pc)
	}
}

func messageReceived(message *sarama.ConsumerMessage) string {
	return string(message.Value)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package main

import (
	"encoding/json"
	"fmt"
	"os"

	"github.com/sirupsen/logrus"

	"./reporter"
	"./subscriber"
)

var (
	config = `{
	"host": "localhost:9092",
	"topic": "kafka_test"
  }`
)

func main() {
	var cfg reporter.KafkaCfg
	json.Unmarshal([]byte(config), &cfg)
	log := &logrus.Logger{Out: os.Stdout}

	//reporter
	producer := reporter.NewReporter(&cfg, log)
	//subscriber
	consumer := subscriber.NewSubscriber(&cfg, log)
	message := "Hello Kafka World."

	ch := make(chan string)
	consumer.Consume(cfg.Topic, ch)
	producer.DoReport(cfg.Topic, []byte(message))

	select {
	case msg := <-ch:
		fmt.Println("Got msg: ", msg)
		break
	}
}

1
2
3
4
5
6
7
8
9

.
├── README.md
├── error_const
│   └── error_const.go
├── main.go
├── reporter
│   └── report.go
└── subscriber
    └── subscribe.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package main

import (
	"encoding/json"
	"fmt"
)

type person struct {
	Name    string `json:"name"`
	Country string `json:"country"`
	City    string `json:"city"`
}

func main() {
	amy := person{
		Name:    "Amy",
		Country: "China",
		City:    "Beijing",
	}
	data1, _ := json.Marshal(amy)
	fmt.Println(string(data1))
	data2, _ := json.MarshalIndent(amy, "", "    ")
	fmt.Println(string(data2))
}

1
2
3
4
5
6

{"name":"Amy","country":"China","city":"Beijing"}
{
   "name": "Amy",
   "country": "China",
   "city": "Beijing"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package main

import (
	"encoding/json"
	"fmt"
)

type person struct {
	Name    string `json:"name"`
	Country string `json:"country"`
	City    string `json:"city,omitempty"`
}

func main() {
	amy := person{
		Name:    "Amy",
	}
	data, _ := json.MarshalIndent(amy, "", "    ")
	fmt.Println(string(data))
}

1
2
3
4

{
    "name": "Amy",
    "country": ""
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import (
	"encoding/json"
	"fmt"
)

type person struct {
	Name    string `json:"name"`
	Country string `json:"country"`
	City    string `json:"-"`
}

func main() {
	amy := person{
		Name:    "Amy",
		Country: "China",
		City:    "Beijing",
	}
	data, _ := json.MarshalIndent(amy, "", "    ")
	fmt.Println(string(data))
}

1
2
3
4

{
    "name": "Amy",
    "country": "China"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import (
	"encoding/json"
	"fmt"
)

type person struct {
	Name    string `json:"name"`
	Age     int `json:"age,string"`
}

func main() {
	amy := person{
		Name:    "Amy",
		Age:     25,
	}

	data, _ := json.MarshalIndent(amy,"","    ")
	fmt.Printf("%s\n\n", string(data))
}

1
2
3
4

{
   "name": "Amy",
   "age": "25"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package main

import (
	"encoding/json"
	"fmt"
)

type person struct {
	Name    string `json:"name"`
	Country string `json:"country"`
	City    string `json:"city"`
}

func main() {
	amy := person{
		Name:    "Amy",
		Country: "China",
		City:    "Beijing",
	}
	data, _ := json.MarshalIndent(
		struct {
			person
			Gender string `json:"gender"`
		}{
			person: amy,
			Gender: "female",
		},"","    ")
	fmt.Println(string(data))
}

1
2
3
4
5
6

{
    "name": "Amy",
    "country": "China",
    "city": "Beijing",
    "gender": "female"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package main

import (
	"encoding/json"
	"fmt"
)

type person struct {
	Name    string `json:"name"`
	Country string `json:"country"`
	City    string `json:"city"`
}

type occupation struct {
	Company  string `json:"company"`
	Position string `json:"position"`
}

func main() {
	amy := person{
		Name:    "Amy",
		Country: "China",
		City:    "Beijing",
	}

	job := occupation{
		Company:  "Google",
		Position: "developer",
	}
	data, _ := json.MarshalIndent(
		struct {
			person
			occupation
		}{
			person:     amy,
			occupation: job,
		}, "", "    ")
	fmt.Println(string(data))
}

1
2
3
4
5
6
7

{
    "name": "Amy",
    "country": "China",
    "city": "Beijing",
    "company": "Google",
    "position": "developer"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func (t Time) MarshalJSON() ([]byte, error) {
	if y := t.Year(); y < 0 || y >= 10000 {
		// RFC 3339 is clear that years are 4 digits exactly.
		// See golang.org/issue/4556#c15 for more discussion.
		return nil, errors.New("Time.MarshalJSON: year outside of range [0,9999]")
	}

	b := make([]byte, 0, len(RFC3339Nano)+2)
	b = append(b, '"')
	b = t.AppendFormat(b, RFC3339Nano)
	b = append(b, '"')
	return b, nil
}

1
2
3

type Marshaler interface {
        MarshalJSON() ([]byte, error)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package main

import (
	"encoding/json"
	"fmt"
	"time"
)

//自定义时间类型
type MyTime time.Time

// 实现Marshaler接口
func (mytime MyTime) MarshalJSON() ([]byte, error) {
	n := time.Time(mytime).Format("2006-01-02 15:04")
	t := "\"" + n + "\""
	return []byte(t), nil
}

type person struct {
	Name     string `json:"name"`
	Country  string `json:"country"`
	City     string `json:"city"`
	Birthday MyTime `json:"birthday"`
}

func main() {
	amy := person{
		Name:     "Amy",
		Country:  "China",
		City:     "Beijing",
		Birthday: MyTime(time.Now()),
	}
	data, _ := json.MarshalIndent(amy, "", "    ")
	fmt.Println(string(data))
}

1
2
3
4
5
6

{
    "name": "Amy",
    "country": "China",
    "city": "Beijing",
    "birthday": "2019-09-05 18:42"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package main

import (
	"encoding/json"
	"fmt"
)

type person struct {
	Name    string `json:"name"`
	Country string `json:"country"`
	City    string `json:"city"`
}

func main() {
	data := `{
	"name": "Amy",
	"country": "China",
	"city":"Beijing"
	}`
	amy := person{}
	err := json.Unmarshal([]byte(data), &amy)
	if err == nil {
		fmt.Printf("%s\n%s\n%s\n", amy.Name, amy.Country, amy.City)
	}
}

1
2
3

Amy
China
Beijing

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package main

import (
	"encoding/json"
	"fmt"
)

type person struct {
	Name    string `json:"name"`
	Country string `json:"country"`
	City    string `json:"city"`
}

type occupation struct {
	Company  string `json:"company"`
	Position string `json:"position"`
}

func main() {
	data := `{
	"name": "Amy",
	"country": "China",
	"city":"Beijing",
	"company":"Google",
	"position":"developer"
	}`

	amy := person{}
	job := occupation{}

	err := json.Unmarshal([]byte(data),
		&struct {
			*person
			*occupation
		}{&amy, &job})
	if err == nil {
		fmt.Printf("%v\n%v\n", amy, job)
	}
}

1
2

{Amy China Beijing}
{Google developer}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name    string `json:"name"`
	country string `json:"country"`
}

func main() {
	d := `{
	"name": "Amy",
	"country": "China"
	}`

	amy := Person{}

	err := json.Unmarshal([]byte(d),&amy)
	if err == nil {
		fmt.Printf("%v\n", amy)
	}

  Sam := Person{
    Name: "Sam",
    country: "CN",
  }
  data,err := json.Marshal(Sam)
	if err == nil {
		fmt.Printf("%v\n", string(data))
	}
}

1
2

{Amy}
{"name":"Sam"}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

type MyArray struct {
	Data []interface{}
	Size int
}

func NewMyArray(size int) *MyArray {
	if size == 0 {
		return nil
	}

	return &MyArray{
		make([]interface{}, size),
		size,
	}
}

1
2
3
4
5
6
7

func (m *MyArray) resize() {
	newArray := make([]interface{}, 2*m.Size)
	for i := 0; i <= m.Size; i++ {
		newArray[i] = m.Data[i]
	}
	m.Data = newArray
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func (m *MyArray) AddItem(item interface{}) {
	if len(m.Data) == m.Size {
		m.resize()
	}
	m.Data[m.Size] = item
	m.Size++
}

func (m *MyArray) AddItems(items ...interface{}) {
	for item := range items {
		m.AddItem(item)
	}
}

1
2
3
4
5
6
7
8
9

// 删
func (m *MyArray) Remove(target interface{}) {
	newArray := make([]interface{}, len(m.Data))
	for i := 0; i < m.Size; i++ {
		if m.Data[i] != target {
			newArray = append(newArray, m.Data[i])
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func (m *MyArray) RemoveWithIndex(index int) {
	if index < 0 || index > len(m.Data) {
		panic("Illegal index.")
	}
	newArray := make([]interface{}, len(m.Data))
	for i := 0; i < m.Size; i++ {
		if i != index {
			newArray[i] = m.Data[i]
		}
	}
	m.Data = newArray
}

1
2
3
4
5
6

func (m *MyArray) Set(index int, item interface{}) {
	if index < 0 || index > len(m.Data) {
		panic("Illegal index.")
	}
	m.Data[index] = item
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func (m *MyArray) FindItem(target interface{}) int {
	for i := 0; i < m.Size; i++ {
		if m.Data[i] == target {
			return i
		}
	}
	return -1
}

func (m *MyArray) FindAllItems(target interface{}) (result []int) {
	for i := 0; i < m.Size; i++ {
		if m.Data[i] == target {
			result = append(result, i)
		}
	}
	return
}

func (m *MyArray) Contains(target interface{}) bool {
	if m.FindItem(target) == -1 {
		return false
	}
	return true
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func (m *MyArray) GetItem(index int) interface{} {
	if index > len(m.Data) || index < 0 {
		return nil
	}
	return m.Data[index]
}

func (m *MyArray) GetItems(indexes ...int) []interface{} {
	result := make([]interface{}, len(indexes))
	for i := range indexes {
		if i >= 0 && i < m.Size {
			result = append(result, m.Data[i])
		}
	}

	return result
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func (m *MyArray) GetCapacity() int {
	return len(m.Data)
}

func (m *MyArray) GetSize() int {
	return m.Size
}

func (m *MyArray) IsEmpty() bool {
	return m.Size == 0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

type hchan struct {
	qcount   uint           // 队列中的数据的量
	dataqsiz uint           // 环形队列的大小
	buf      unsafe.Pointer // 指向 dataqsiz 大小的的数组
	elemsize uint16 // 元素大小
	closed   uint32 // 是否关闭
	elemtype *_type // 元素类型
	sendx    uint   // 发送索引
	recvx    uint   // 接收索引
	recvq    waitq  // 接收列表即 <-chan
	sendq    waitq  // 发送列表即 ch<-

	lock mutex
	// lock保护 hchan 结构体内的所有字段，以及 waitq 内的 sudog，
	// 在持有该锁时，不要改变 G 的状态，因为在栈收缩时会死锁
}


type waitq struct {
	first *sudog
	last  *sudog
}

1
2
3
4
5
6

type CacheItemPair struct {
	Key         interface{}
	AccessCount int64
}

type CacheItemPairList []CacheItemPair

1
2
3

func (p CacheItemPairList) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p CacheItemPairList) Len() int           { return len(p) }
func (p CacheItemPairList) Less(i, j int) bool { return p[i].AccessCount > p[j].AccessCount }

1
2
3
4
5
6
7
8
9

type Interface interface {
	// Len is the number of elements in the collection.
	Len() int
	// Less reports whether the element with
	// index i should sort before the element with index j.
	Less(i, j int) bool
	// Swap swaps the elements with indexes i and j.
	Swap(i, j int)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

func (table *CacheTable) MostAccessed(count int64) []*CacheItem {
	table.RLock()
	defer table.RUnlock()

	p := make(CacheItemPairList, len(table.items))
	i := 0
	for k, v := range table.items {
		p[i] = CacheItemPair{k, v.accessCount}
		i++
	}
	sort.Sort(p)

	var r []*CacheItem
	c := int64(0)
	// p经过排序后，通过遍历构造新的items list
	for _, v := range p {
		if c >= count {
			break
		}

		item, ok := table.items[v.Key]
		if ok {
			r = append(r, item)
		}
		c++
	}

	return r
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// 待存储的元素的结构体定义
type myStruct struct {
	text     string
	moreData []byte
}

func main() {
	// 创建一个缓存表
	cache := cache2go.Cache("myCache")

  // 准备元素
	val := myStruct{"This is a test!", []byte{}}

  // 缓存表添加元素，设定过期时间
	cache.Add("someKey", 5*time.Second, &val)

	// 从缓存中获取元素
	res, err := cache.Value("someKey")
	if err == nil {
		fmt.Println("Found value in cache:", res.Data().(*myStruct).text)
	} else {
		fmt.Println("Error retrieving value from cache:", err)
	}

	// 等待直至元素过期
	time.Sleep(6 * time.Second)
	res, err = cache.Value("someKey")
	if err != nil {
		fmt.Println("Item is not cached (anymore).")
	}

	// 添加新的永不过期的元素
	cache.Add("someKey", 0, &val)

	// 设置删除元素时给反馈
	cache.SetAboutToDeleteItemCallback(func(e *cache2go.CacheItem) {
		fmt.Println("Deleting:", e.Key(), e.Data().(*myStruct).text, e.CreatedOn())
	})

	// 移除元素
	cache.Delete("someKey")

	// 清空缓存
	cache.Flush()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

type CacheItem struct {
	sync.RWMutex

	// 元素的key
	key interface{}
	// 元素内容
	data interface{}
	// 元素生命周期
	lifeSpan time.Duration

	// 创建时间
	createdOn time.Time
	// 最后被访问时间
	accessedOn time.Time
	// 访问次数
	accessCount int64

	// 到期签可触发的方法
	aboutToExpire []func(key interface{})
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func NewCacheItem(key interface{}, lifeSpan time.Duration, data interface{}) *CacheItem {
	t := time.Now()
	return &CacheItem{
		key:           key,
		lifeSpan:      lifeSpan,
		createdOn:     t,
		accessedOn:    t,
		accessCount:   0,
		aboutToExpire: nil,
		data:          data,
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

func (item *CacheItem) KeepAlive() {
	item.Lock()
	defer item.Unlock()
	item.accessedOn = time.Now()
	item.accessCount++
}

func (item *CacheItem) AccessedOn() time.Time {
	item.RLock()
	defer item.RUnlock()
	return item.accessedOn
}

func (item *CacheItem) AccessCount() int64 {
	item.RLock()
	defer item.RUnlock()
	return item.accessCount
}

func (item *CacheItem) SetAboutToExpireCallback(f func(interface{})) {
	if len(item.aboutToExpire) > 0 {
		item.RemoveAboutToExpireCallback()
	}
	item.Lock()
	defer item.Unlock()
	item.aboutToExpire = append(item.aboutToExpire, f)
}

func (item *CacheItem) AddAboutToExpireCallback(f func(interface{})) {
	item.Lock()
	defer item.Unlock()
	item.aboutToExpire = append(item.aboutToExpire, f)
}

func (item *CacheItem) RemoveAboutToExpireCallback() {
	item.Lock()
	defer item.Unlock()
	item.aboutToExpire = nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

type CacheTable struct {
	sync.RWMutex

	// 缓存表命名
	name string
	// 缓存表内存储的所有元素，是个slice
	items map[interface{}]*CacheItem

	// 触发清楚的定时器
	cleanupTimer *time.Timer
	// 当前定时器间隔
	cleanupInterval time.Duration

	logger *log.Logger

	// Callback method triggered when trying to load a non-existing key.
	loadData func(key interface{}, args ...interface{}) *CacheItem
	// Callback method triggered when adding a new item to the cache.
	addedItem []func(item *CacheItem)
	// Callback method triggered before deleting an item from the cache.
	aboutToDeleteItem []func(item *CacheItem)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 获取元素个数
func (table *CacheTable) Count() int {
	table.RLock()
	defer table.RUnlock()
	return len(table.items)
}

// 遍历
func (table *CacheTable) Foreach(trans func(key interface{}, item *CacheItem)) {
	table.RLock()
	defer table.RUnlock()

	for k, v := range table.items {
		trans(k, v)
	}
}

1
2
3
4
5
6
7
8
9

func (table *CacheTable) Add(key interface{}, lifeSpan time.Duration, data interface{}) *CacheItem {
	item := NewCacheItem(key, lifeSpan, data)

	// Add item to cache.
	table.Lock()
	table.addInternal(item)

	return item
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func (table *CacheTable) NotFoundAdd(key interface{}, lifeSpan time.Duration, data interface{}) bool {
	table.Lock()

	if _, ok := table.items[key]; ok {
		table.Unlock()
		return false
	}

	// 查找不到元素，则新建元素添加
	item := NewCacheItem(key, lifeSpan, data)
	table.addInternal(item)

	return true
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

func (table *CacheTable) addInternal(item *CacheItem) {
	// Careful: do not run this method unless the table-mutex is locked!
	// It will unlock it for the caller before running the callbacks and checks
	table.log("Adding item with key", item.key, "and lifespan of", item.lifeSpan, "to table", table.name)
	table.items[item.key] = item

	// Cache values so we don't keep blocking the mutex.
	expDur := table.cleanupInterval
	addedItem := table.addedItem
	table.Unlock()

	// Trigger callback after adding an item to cache.
	if addedItem != nil {
		for _, callback := range addedItem {
			callback(item)
		}
	}

	// If we haven't set up any expiration check timer or found a more imminent item.
	if item.lifeSpan > 0 && (expDur == 0 || item.lifeSpan < expDur) {
		table.expirationCheck()
	}
}

1
2
3
4
5
6

func (table *CacheTable) Delete(key interface{}) (*CacheItem, error) {
	table.Lock()
	defer table.Unlock()

	return table.deleteInternal(key)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

func (table *CacheTable) deleteInternal(key interface{}) (*CacheItem, error) {
	r, ok := table.items[key]
	if !ok {
		return nil, ErrKeyNotFound
	}

	// Cache value so we don't keep blocking the mutex.
	aboutToDeleteItem := table.aboutToDeleteItem
	table.Unlock()

	// Trigger callbacks before deleting an item from cache.
	if aboutToDeleteItem != nil {
		for _, callback := range aboutToDeleteItem {
			callback(r)
		}
	}

	r.RLock()
	defer r.RUnlock()
	if r.aboutToExpire != nil {
		for _, callback := range r.aboutToExpire {
			callback(key)
		}
	}

	table.Lock()
	table.log("Deleting item with key", key, "created on", r.createdOn, "and hit", r.accessCount, "times from table", table.name)
	delete(table.items, key)

	return r, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func (table *CacheTable) Flush() {
	table.Lock()
	defer table.Unlock()

	table.log("Flushing table", table.name)

	table.items = make(map[interface{}]*CacheItem)
	table.cleanupInterval = 0
	if table.cleanupTimer != nil {
		table.cleanupTimer.Stop()
	}
}

1
2
3
4

//声明
var ch chan 类型
//初始化
ch := make(chan 类型)

1
2

var ch chan int
ch := make(chan int)

1
2
3
4

ch <- x //往channel中存入数据 x
<- ch // 从channel中取出数据
x <- ch //从channel中取出数据并赋值给 x
close(ch) // 关闭通道

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 这个channel中只存储一个数据
var ch chan int = make(chan int)
// 等同于
var ch chan int = make(chan int, 0)

func foo()  {
	ch <- 0//存消息，如果没有其他goroutine来取走这个数据，那么挂起foo，直到main函数把这个0取走
}

func main()  {
	go foo()
	<- ch//从ch取消息，如果ch中没有数据，就挂起main线程，直到foo函数往ch内放数据
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

var complete chan int = make(chan int)

func loop()  {
	for i:=0 ; i<10 ;i++{
		fmt.Print("%d",i)
	}
	complete <- 0
}

func main()  {
	go loop()
	<- complete //直到线程跑完，取到消息
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

var channel chan int = make(chan int)

func main()  {
	var messages chan string = make(chan string)
	go func (message string)  {
		messages <- message // channel存消息
    // 若未取出这条消息，这个协程将被阻塞
	}
	fmt.Println(<-messages)//channel取消息，消息被取后，阻塞解除
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

//例子1
func main()  {
	var ch := make(chan,int)
	ch <- 1//死锁了，没有线程取走这个数据
	fmt.Println("wrong")
}

//例子2
var ch1 chan int = make(chan int)
var ch2 chan int = make(chan int)
func say(s string)  {
	fmt.Println(s)
	ch1 <- <- ch2//ch1等待ch2的输出
}
func main()  {
	go say("hello")
	<- ch1
}

//例子3
c, quit := make(chan int), make(chan int)
go func() {
   c <- 1  // c通道的数据没有被其他goroutine读取走 堵塞当前goroutine
   quit <- 0 // quit始终没有办法写入数据
}()
<- quit // quit 等待数据的写

//反例
func main() {
    c := make(chan int)
    go func() {
       c <- 1
    }()
}//main未等待其他goroutine 自己先运行完毕了 没有数据流入c通道 一共执行了一个goroutine 没有阻塞 没有死锁

1
2
3
4
5
6
7

var ch chan int = make(chan int, 2) // 写入2个元素都不会阻塞当前goroutine, 存储个数达到2的时候会阻塞
func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
}//若再流入一个数据 信道ch会阻塞main线程 报死锁

1
2
3
4
5
6
7
8

say(){
  fmt.Println("hello world")
}

func main()  {
  say()
  go say()// 创建了一个新协程
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import "fmt"

func loop(round string)  {
	for i := 1; i<=3 ;i++{
		fmt.Printf("Round:%s,\ti:%d\n",round,i)
	}
}

func main()  {
	loop("A")
	loop("B")
}

1
2
3
4
5
6

Round:A,	i:1
Round:A,	i:2
Round:A,	i:3
Round:B,	i:1
Round:B,	i:2
Round:B,	i:3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import "fmt"

func loop(round string)  {
	for i := 1; i<=3 ;i++{
		fmt.Printf("Round:%s,\ti:%d\n",round,i)
	}
}

func main()  {
	go loop("B")
  loop("A")
}

1
2
3

Round:A,	i:1
Round:A,	i:2
Round:A,	i:3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

import (
  "fmt"
  "time"
)

func loop(round string)  {
	for i := 1; i<=3 ;i++{
		fmt.Printf("Round:%s,\ti:%d\n",round,i)
	}
}

func main()  {
	go loop("B")
  loop("A")
  go loop("C")
  time.Sleep(time.Second)
}

1
2
3
4
5
6

Round:A,	i:1
Round:A,	i:2
Round:A,	i:3
Round:B,	i:1
Round:B,	i:2
Round:B,	i:3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package main

import (
    "fmt"
    "sync"
)

func goRun(round string, wg *sync.WaitGroup)  {
  defer wg.Done()
  loop(round)
}
func loop(round string)  {
	for i := 1; i<=3 ;i++{
		fmt.Printf("Round:%s,\ti:%d\n",round,i)
	}
}

func main()  {
  var wg sync.WaitGroup

  wg.Add(3)
  go goRun("A",&wg)
  go goRun("B",&wg)
  go goRun("C",&wg)

  wg.Wait()
}

1
2
3
4
5
6
7
8
9

Round:C,	i:1
Round:C,	i:2
Round:C,	i:3
Round:A,	i:1
Round:A,	i:2
Round:A,	i:3
Round:B,	i:1
Round:B,	i:2
Round:B,	i:3

1
2
3
4
5

type 接口名 interface{
  方法1
  方法2
  ...
}

1
2
3

type AInterface interface{
  Say()
}

1
2
3
4

type AInterface interface{
  Say()
  Name string //这里会报错，不可以包含变量
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import "fmt"

type AInterface interface{
  Say()
  Write()
}

type integer int

// 用integer去只实现了接口中的Say方法
func (i integer) Say(){
  fmt.Println("hello")
}

func main(){
  var i integer = 10
  var b AInterface = i
  b.Say()
}

1
2

cannot use i (type integer) as type AInterface in assignment:
	integer does not implement AInterface (missing Write method)