• Lightweight RPC based communications
• Event broadcasting and notifications
• CRDT Data synchronisation and storage
• Consensus protocol and execution engine
• WebAssembly target compilation support
• Unique randomized token generation aka BLS
• P2P gossip networking defined in user space

• 基于轻量级的RPC通信
• 事件驱动和消息通知
• CRDT数据同步和存储（CRDT是Conflict-free Replicated Data Type的简称,也称为a passive synchronisation,即免冲突的可复制的数据类型）
• 一致的协议和执行引擎
• 实验性的编译器支持
• 唯一token生成器BLS
• 用户空间自定义P2P网络

两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 
输出：7 -> 0 -> 8
原因：342 + 465 = 807LeetCode

func myPow(a,n int) int {

  result := int(1)

  for i:= n; i >0 ; i >>= 1 {

    if i&1 != 0 {

      result *=a

    }

    a *=a

  }

  return result

}

​

func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {

  var a,b,c,i,j int

  p1 := l1

  for p1!= nil {

    a = a + p1.Val * myPow(10,i)

    i++

    p1 = p1.Next

  }

  p2 := l2

  for p2!= nil {

    b = b + p2.Val * myPow(10,j)

    j++

    p2 = p2.Next

  }

  c = a + b

​

  str := strconv.Itoa(c)

  headNode := new(ListNode)

  current := headNode

  current.Next = nil

  for _,one := range str {

    preNode := current

    current.Val = int(one-48)

    current = new(ListNode)

    current.Next = preNode

​

  }

  

  return current.Next

}

func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {

    headList := new(ListNode)

    head := headList

    num := 0



    for (l1 != nil || l2 != nil || num > 0) {

        headList.Next =  new(ListNode)

        headList = headList.Next

        if l1 != nil {

            num = num + l1.Val

            l1 = l1.Next

        }

        if l2 != nil {

            num = num + l2.Val

            l2 = l2.Next

        }

        headList.Val = (num) % 10

        num = num / 10 

    }



    return head.Next

}

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 

示例： 

给定 nums = [2, 7, 11, 15], target = 9 

因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]LeetCode
 

func twoSum(nums []int, target int) []int {

    len := len(nums)

    var x,y int



    for i:=0; i < len && x|y == 0; i++ {

        findNum := target - nums[i]

        for j:=0; j < len; j++ {

            if findNum == nums[j] {

                x = i;

                y = j;

            }

        }

        

    }



    return []int{x,y}

}

func twoSum(nums []int, target int) []int {

    var hashMap map[int]int

    len := len(nums)

    var x,y,found int



    //初始化字典

    hashMap = make(map[int]int)

    for i:=0; i < len; i++ {

        hashMap[nums[i]] = i

    }



    for j:=0; j < len && found == 0; j++ {

        findNum := target - nums[j]

        v, ok := hashMap[findNum]

        if ok && v != j {

            found = 1

            x = j

            y = v

        }

        

    }



    return []int{x,y}

}

var bufpool = sync.Pool{

    New: func() interface{} {

        buf := make([]byte, 512)

        return &buf

    }}

// reset resets all fields of the AuthenticationResponse before pooling it.

func (a* AuthenticationResponse) reset() {

    a.Token = ""

    a.UserID = ""

}



rsp := authPool.Get().(*AuthenticationResponse)

defer func() {

    rsp.reset()

    authPool.Put(rsp)

}()

import (

    "fmt"

    "runtime"

    "strconv"

    "time"

)



const (

    numElements = 10000000

)



var foo = map[string]int{}



func timeGC() {

    t := time.Now()

    runtime.GC()

    fmt.Printf("gc took: %s\n", time.Since(t))

}



func main() {

    for i := 0; i < numElements; i++ {

        foo[strconv.Itoa(i)] = i

    }



    for {

        timeGC()

        time.Sleep(1 * time.Second)

    }

}

gc took: 98.726321ms

gc took: 105.524633ms

gc took: 102.829451ms

gc took: 102.71908ms

gc took: 103.084104ms

gc took: 104.821989ms

import (

    "fmt"

    "runtime"

    "time"

)



const (

    numElements = 10000000

)



var foo = map[int]int{}



func timeGC() {

    t := time.Now()

    runtime.GC()

    fmt.Printf("gc took: %s\n", time.Since(t))

}



func main() {

    for i := 0; i < numElements; i++ {

        foo[i] = i

    }



    for {

        timeGC()

        time.Sleep(1 * time.Second)

    }

}

gc took: 3.608993ms

gc took: 3.926913ms

gc took: 3.955706ms

gc took: 4.063795ms

gc took: 3.91519ms

gc took: 3.75226ms

package json



// Marshal take an object and returns its representation in JSON.

func Marshal(obj interface{}) ([]byte, error) {

    // Check if this object knows how to marshal itself to JSON

    // by satisfying the Marshaller interface.

    if m, is := obj.(json.Marshaller); is {

        return m.MarshalJSON()

    }



    // It doesn't know how to marshal itself. Do default reflection based marshallling.

    return marshal(obj)

}

easyjson -all $file.go$file.go

pkg: github.com/sjwhitworth/perfblog/strbuild

BenchmarkStringBuildNaive-8          5000000           255 ns/op         216 B/op          8 allocs/op

BenchmarkStringBuildBuilder-8       20000000            54.9 ns/op        64 B/op          1 allocs/op

BenchmarkStrconv-8      30000000            39.5 ns/op        32 B/op          1 allocs/op

BenchmarkFmt-8          10000000           143 ns/op          72 B/op          3 allocs/op

data：切片中指向底层数据的指针
len：切片中的当前元素数目
cap：在不重新分配内存的前提下，切片能够增长到的元素数目

var userIDs []string

for _, bar := range rsp.Users {

    userIDs = append(userIDs, bar.ID)

}

userIDs := make([]string, 0, len(rsp.Users)

for _, bar := range rsp.Users {

    userIDs = append(userIDs, bar.ID)

}

//该编译后的程序可以在32或64位机器上运行

linux> gcc -m32 prog.c

​

//该编译后，只能在64位机器上运行

linux> gcc -m64 prog.c

1.随机性发现的Bad case
2.KPI或者OKR考核
3.业务方诉求

• “搜索PV”：指访问搜索页面的次数；
• “搜索UV”：访问过搜索结果页的用户数；
• “无结果率”：空结果PV/搜索PV，无结果率越低，代表客户搜索需求解决情况越好；
• “TOP5 PV—CTR”：指该query search结果中，排在前五位的item有被点击的搜索PV/该query搜索PV该指标能一定程度反应排序效果；
• “人均搜索PV”：搜索PV/搜索UV；该指标的含义比较复杂，一方面人均pv大的话可能代表用户对搜索比较感兴趣，但另一方面人均pv大也可能代表搜索召回的结果较差，导致用户无法使用较少的点击找到满足需求的结果；
• “有点击搜索PV占比”：有点击搜索PV/搜索PV数；
• “PV-CTR”:搜索结果页item点击数/搜索PV数；
• “UV-CTR”:点击的uv / 曝光的uv；
• “Item-CTR”：搜索结果页item点击数/搜索结果页item总曝光PV数；

无符号编码：基于传统的二进制表示法，表示大于或者等于0的数字；
补码编码：表示有符号整数的最常见方式；
浮点数编码：表示实数的科学计数法的以2为基数的版本；

linux> gcc -std=c11 zkbhj.c

//其他版本参数

//GNU 89 无，-std=gnu89

//ANSI ,ISO C90 -ansi,-std=c89

//ISO C99 -std=c99

//ISO C11 -std=c11

var uselessChan = make(chan<- int, 1)

var uselessChan = make(<-chan int, 1)

//参数定义中就约束 ch只能进行发送操作，不能接收

//可以限制方法函数内对参数的操作行为做限定

func SendInt(ch chan<- int) { 

    ch <- rand.Intn(1000)

}

//这段接口声明中，就约定了所以要实现这个接口的实现类型

//都约定了这些方法的参数类型

type Notifier interface { 

  SendInt(ch chan<- int)

}

select {

case <-intChannels[0]: 

fmt.Println("The first candidate case is selected.")

case <-intChannels[1]: 

fmt.Println("The second candidate case is selected.")

case elem := <-intChannels[2]: fmt.Printf("The third candidate case is selected, the element is %d.\n", elem)

default: fmt.Println("No candidate case is selected!")

}

1、对于每一个case表达式，都至少会包含一个代表发送操作的发送表达式或者一个代表接收操作的接收表达式；
2、select语句包含的候选分支中的case表达式都会在该语句执行开始时先被求值，并且求值的顺序是依从代码编写的顺序从上到下的；
3、对于每一个case表达式，如果其中的发送表达式或者接收表达式在被求值时，相应的操作正处于阻塞状态，那么对该case表达式的求值就是不成功的；
4、仅当select语句中的所有case表达式都被求值完毕后，它才会开始选择候选分支。这时候，它只会挑选满足选择条件的候选分支执行。所有的都不满足，执行default；
5、如果select语句发现同时有多个候选分支满足选择条件，那么它就会用一种伪随机的算法在这些分支中选择一个并执行；

1. ​中国发展仍处于战略机遇期
2. 从持久战角度认识中长期问题
3. 以国内大循环为主题
4. 建立中长期协调机制
5. 牢牢把握扩大内需这个战略基点
6. 确保宏观政策落地见效
7. 保持货币供应量合理增长
8. 毫不放松抓好常态化疫情防控
9. 扩大最终消费
10. 加快新基建
11. 以新型城镇化带动投资和消费
12. 产业链补短板和锻长板
13. 从严打击证券违法活动
14. 住房不炒
15. 缓解疫情对年轻人就业影响

“在泡沫中狂欢的日志不多了，做好潮水退却后的准备，是每个国家，每个人都要面对的现实”

——吴晓灵 前央行副行长

主要思想是：当对系统的某个部分加速时，其对系统整体性能的影响取决于该部分的重要性和加速程度。
主要观点是：想要显著加速整个系统，必须提升全系统中相当大的部分的速度。

一周的早读，完成了《深入理解计算机系统》这本又厚又重的计算机最底层原理书籍第一章的阅读和理解。
好好利用碎片时间，以及找到自己的高效时间段及学习方式很重要。
积少成多，积流成河！
明天开启第二章：程序结构和执行！

1、打开美团APP，点击进入个人中心页面，点击右上角的在线客服，进入客服聊天界面；

2、输入问题：支付宝无法使用；

3、在返回的结果里选择：放弃优惠，恢复支付宝。

Don’t communicate by sharing memory; share memory by communicating. （不要通过共享内存来通信，而应该通过通信来共享内存。）

1、键盘输入"./hello"后，shell程序将字符逐一读入寄存器，再把它们存放到主存中；
2、敲击回车，shell就知道我们已经输入结束了，然后shell会执行一系列指令，将hello程序中的代码和数据从磁盘复制到主存。这其中利用了直接存储器存取（DMA），数据直接通过总线从磁盘进入主存中，不会经过处理器；
3、代码和数据加载完毕之后，处理器就开始执行hello程序的main程序中的机器语言指令，将数据（hello,world\n）字符串中的字符从主存中复制到寄存器文件中，再从寄存器文件中复制到显示器设备，最终显示出结果。

1. 防止硬件被失控的应用程序滥用；
2. 向应用程序提供简单一致的机制来控制复杂而又通常大不相同的低级硬件设备。

• 文件：是对I/O设备的抽象表示；
• 虚拟内存：是对主存和磁盘I/O设备的抽象表示；
• 进程：是对处理器、主存和磁盘I/O设备的抽象表示。Posix标准是IEEE组织为了组织Unix越来越混乱，越来越不标准化而制定的标准化Unix开发提出来的一套标准规范。

深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。

如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值）
如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值）

package main



import (

   "fmt"

)



// 定义一个Robot结构体

type Robot struct {

   Name  string

   Color string

   Model string

}



func main() {

   fmt.Println("深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。")

   robot1 := Robot{

      Name:  "小白-X型-V1.0",

      Color: "白色",

      Model: "小型",

   }

   robot2 := robot1

   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)



   fmt.Println("修改Robot1的Name属性值")

   robot1.Name = "小白-X型-V1.1"



   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)



}

深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。

Robot 1：{小白-X型-V1.0 白色 小型}      内存地址：0xc000072330

Robot 2：{小白-X型-V1.0 白色 小型}      内存地址：0xc000072360

修改Robot1的Name属性值

Robot 1：{小白-X型-V1.1 白色 小型}      内存地址：0xc000072330

Robot 2：{小白-X型-V1.0 白色 小型}      内存地址：0xc000072360

package main



import (

   "fmt"

)



// 定义一个Robot结构体

type Robot struct {

   Name  string

   Color string

   Model string

}



func main() {



   fmt.Println("浅拷贝 使用new方式")

   //new方式返回的是一个指针，是引用类型，所以会触发浅拷贝

   robot1 := new(Robot)

   robot1.Name = "小白-X型-V1.0"

   robot1.Color = "白色"

   robot1.Model = "小型"



   robot2 := robot1

   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)



   fmt.Println("在这里面修改Robot1的Name和Color属性")

   robot1.Name = "小蓝-X型-V1.2"

   robot1.Color = "蓝色"



   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)

}

浅拷贝 使用new方式

Robot 1：&{小白-X型-V1.0 白色 小型}     内存地址：0xc000068330

Robot 2：&{小白-X型-V1.0 白色 小型}     内存地址：0xc000068330

在这里面修改Robot1的Name和Color属性

Robot 1：&{小黑-X型-V1.2 黑色 小型}     内存地址：0xc000068330

Robot 2：&{小黑-X型-V1.2 黑色 小型}     内存地址：0xc000068330

package main



import (

   "fmt"

)



// 定义一个Robot结构体

type Robot struct {

   Name  string

   Color string

   Model string

}



func main() {



   fmt.Println("浅拷贝 内容和内存地址一样，改变其中一个对象的值时，另一个同时变化。")

   robot1 := Robot{

      Name:  "小白-X型-V1.0",

      Color: "白色",

      Model: "小型",

   }

   robot2 := &robot1

   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)



   fmt.Println("在这里面修改Robot1的Name和Color属性")

   robot1.Name = "小黑-X型-V1.1"

   robot1.Color = "黑色"



   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)



}

...

"".B STEXT nosplit size=1 args=0x8 locals=0x0

    0x0000 00000 (main.go:9)    TEXT    "".B(SB), NOSPLIT|ABIInternal, $0-8

    0x0000 00000 (main.go:9)    PCDATA    $0, $-2

    0x0000 00000 (main.go:9)    PCDATA    $1, $-2

    0x0000 00000 (main.go:9)    FUNCDATA    $0, gclocals·2a5305abe05176240e61b8620e19a815(SB)

    0x0000 00000 (main.go:9)    FUNCDATA    $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)

    0x0000 00000 (main.go:9)    FUNCDATA    $2, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)

    0x0000 00000 (main.go:11)    PCDATA    $0, $-1

    0x0000 00000 (main.go:11)    PCDATA    $1, $-1

    0x0000 00000 (main.go:11)    RET

    0x0000 c3

...

...

Load command 1

      cmd LC_SEGMENT_64

  cmdsize 632

  segname __TEXT

   vmaddr 0x0000000001000000

   vmsize 0x0000000000167000

  fileoff 0

 filesize 1470464

  maxprot rwx

 initprot r-x

   nsects 7

    flags (none)

Section

  sectname __text

   segname __TEXT

      addr 0x0000000001001000

      size 0x000000000009c365

    offset 4096

     align 2^4 (16)

    reloff 0

    nreloc 0

      type S_REGULAR

attributes PURE_INSTRUCTIONS SOME_INSTRUCTIONS

 reserved1 0

 reserved2 0

...

type T struct {

    name string

}



func (t T) Name() string {

    return "Hi! " + t.name

}



func main() {

    t := T{name: "test"}

    fmt.Println(t.Name())   // Hi! test

    fmt.Println(T.Name(t))  // Hi! test

}

func getFunc() func() int {

    a := 0

    return func() int {

        a++

        return a

    }

}



func main() {

    f := getFunc()

    for i := 0; i < 10; i++ {

        fmt.Println(f())

    }

}