发表于 | 分类于
字数统计: 442 | 阅读时长 ≈ 1

1.缓存处理流程。

​ 前台请求，后台先从缓存中取数据，取到之后直接返回结果，取不到时从数据库取，数据库取到更新缓存

并返回，取不到直接返回空结果。

2.缓存穿透

问题：是指缓存和数据库中都没有的数据，而用户不断发起请求，这时用户可能是攻击者，攻击会导致数据库压力过大。

解决：

1. 接口层增加校验，例如用户权限校验，合法性校验，请求校验。
 2. 缓存中取不到的数据，数据库中也不存在，可暂时设置一个key-null键值对，有效时间较短，防止用户对同一个数据进行暴力攻击。

3.缓存击穿

问题：是指缓存中没有但是数据库中有的数据，这时由于并发用户较多，同时读缓存没读到数据，同时去数据库取数据，引起数据库瞬间压力过大。

解决：

1. 设置热点数据永不过期。
 2. 热点数据互斥锁处理。

4.缓存雪崩

描述：是指缓存中数据大批量到期时间，而查询数据量巨大，引起数据库压力过大，缓存击穿指的是并发查同一条数据，雪崩是不同的数据都过期了，很多数据都查不到从而查数据库。

解决：

1. 数据缓存时间差异化，减少同一时间大量数据过期现象发生。
 2. 缓存数据分布式处理，热点数据均匀分布在不同的缓存数据库中。
 3. 热点数据永不过期。（可以根据一定的权重定期清理热点数据）

发表于 | 分类于
字数统计: 643 | 阅读时长 ≈ 3

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package main

import (
	"encoding/json"
	"fmt"
)

type Teacher struct {
	Id      int    `json:"-"`                 //表示 在使用json编码时，这个编码不参与
	Name    string `json:"Teacher_name"`      //表示 在使用json编码时，key会使用Teacher_name
	Age     int    `json:"age,string"`        //表示 在使用json编码时，将age转成string类型，切记中间是逗号，不能有空格
	Address string `json:"address,omitempty"` //表示 在使用json编码时，如果这个字段是空值，那么忽略掉，不参与编码
	gender  string
}

// type Teacher struct {
// 	Name string
// 	Id   int
// }

func main() {
	tokey := Teacher{
		Id:     1,
		Name:   "tokey",
		Age:    20,
		gender: "男"}
	encodeInfo, err := json.Marshal(&tokey)
	if err != nil {
		fmt.Println("Marshal error,err:", err)
		return
	}

	fmt.Println("encodeInfo string:", string(encodeInfo))

	var tokey1 Teacher
	err = json.Unmarshal([]byte(encodeInfo), &tokey1)
	if err != nil {
		fmt.Println("Unmarshal error,err:", err)
		return
	}
	fmt.Println("tokey1:", tokey1)
}

// 1. 对于结构体进行编码（json）时：首字母必须大写，否则不参与编码
// 2. 如果json格式要求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
Tokey@DESKTOP-7UHT0GC MINGW64 /e/GoPath/src/day05
$ go run 03-结构体标签.go 
encodeInfo string: {"Id":1,"Name":"tokey","Age":20}
tokey1: {1 tokey 20 }

Tokey@DESKTOP-7UHT0GC MINGW64 /e/GoPath/src/day05
$ go run 03-结构体标签.go 
encodeInfo string: {"Name":"tokey","Age":20}
tokey1: {0 tokey 20 }

Tokey@DESKTOP-7UHT0GC MINGW64 /e/GoPath/src/day05
$ go run 03-结构体标签.go 
encodeInfo string: {"Teacher_name":"tokey","age":"20"}
tokey1: {0 tokey 20 }

Tokey@DESKTOP-7UHT0GC MINGW64 /e/GoPath/src/day05
$ go run 03-结构体标签.go 
encodeInfo string: {"Teacher_name":"tokey","age":"20"}
tokey1: {0 tokey 20 }

Tokey@DESKTOP-7UHT0GC MINGW64 /e/GoPath/src/day05
$ go run 03-结构体标签.go 
encodeInfo string: {"Teacher_name":"tokey","age":"20","Address":""}
tokey1: {0 tokey 20  }

Tokey@DESKTOP-7UHT0GC MINGW64 /e/GoPath/src/day05
$ go run 03-结构体标签.go 
encodeInfo string: {"Teacher_name":"tokey","age":"20"}
tokey1: {0 tokey 20  }

总结

  1. 对于结构体进行编码（json）时，首字母必须大写，否则不参与编码。

  2. 如果json格式要求key小写，那么可以通过标签实现。

  3. 标签（tag）说明：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    type Teacher struct {
        //表示 在使用json编码时，这个编码不参与
    	Id      int    `json:"-"`       
        //表示 在使用json编码时，key会使用Teacher_name
    	Name    string `json:"Teacher_name"`      
        //表示 在使用json编码时，将age转成string类型，切记中间是逗号(不能省略)，不能有空格
    	Age     int    `json:",string"`        
        //表示 在使用json编码时，如果这个字段是空值，那么忽略掉，不参与编码
    	Address string `json:",omitempty"` 
    	gender  string
    }

发表于 | 分类于
字数统计: 2.5k | 阅读时长 ≈ 11

go并发相关学习01

1.基础

  • c语言并发最小单位是线程，即多线程。
  • go语言中不是线程，而是go程->goroutine。
  • 一个go程占用的系统资源远远小于线程，默认大约需要4k-5k的内存资源。
  • 使用go程，只要在目标函数前加上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
25
26
27
28
29
30
package main

import (
	"fmt"
	"time"
)

func disPlay() {
	count := 1
	for {
		fmt.Println("======子go程:", count)
		count++
		time.Sleep(500 * time.Millisecond)
	}
}

func main() {

	//子go程
	go disPlay()

	//主go程
	count := 1
	for {
		fmt.Println("主go程:", count)
		count++
		time.Sleep(1 * time.Second)
	}

}
1
2
3
4
5
6
7
8
9
go程: 1      
======子go程: 1
======子go程: 2
======子go程: 3
主go程: 2
======子go程: 4
主go程: 3
======子go程: 5
======子go程: 6

2.提前退出

阅读全文 »

发表于 | 分类于
字数统计: 968 | 阅读时长 ≈ 4

go基础语法学习03

1.类构建和成员函数

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"

type Person struct {
	name string
	age  int
}

func (p Person) Eat() {
	fmt.Println(p.name, "is eating")
	p.name = "name1"	//这里p是对象的拷贝，修改p不会影响源对象
}

func (this *Person) Eat2() {
	fmt.Println(this.name, "is eating")
	this.name = "name2"	//这里this是指向源对象，修改this会影响源对象
}

func main() {
	tokey := Person{"tokey", 20}

	//用指针绑定成员函数，可以直接修改成员变量。
	//另一种方法绑定成员函数，用的是拷贝，修改之后不影响源对象。
	tokey.Eat()
	tokey.Eat2()
}

go没有class，但是可以用struct实现class的概念。

阅读全文 »

发表于 | 分类于
字数统计: 876 | 阅读时长 ≈ 4

go基础语法学习02

1. switch

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 (
	"fmt"
	"os"
)

func main() {

	cmds := os.Args

	for key, val := range cmds {
		fmt.Println("key:", key, "val:", val, "cmds len:", len(cmds))
	}

	switch cmds[1] {
	case "hello":
		fmt.Println("hello")
		fallthrough
	case "world":
		fmt.Println("world")
	default:
		fmt.Println("default")
	}
}

  1. os.Args 表示获取程序的输入参数,类似于C++的 argv**

  2. go的switch默认不需要加break，编译器会自动补上，如果使用fallthrough，编译器则不会给该case下补break

阅读全文 »
0%