• 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网络

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)

}

...

"".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())

    }

}

slice在并发执行中不会报错，但是数据会丢失；
map在并发执行中会直接报错（fatal error: concurrent map writes）。

var s []int



func appendValue(i int) {

	s = append(s, i)

}



func main() {

	for i := 0; i < 10000; i++ { //10000个协程同时添加切片

		go appendValue(i)

	}



	for i, v := range s { 		//同时打印索引和值

		fmt.Println(i, ":", v)

	}

}

var s []int

var lock sync.Mutex //互斥锁

func appendValue(i int) {

	lock.Lock() //加锁

	s = append(s, i)

	lock.Unlock() //解锁

}



func main() {

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

		go appendValue(i)

	}

	//sort.Ints(s) //给切片排序,先排完序再打印,和下面一句效果相同

	time.Sleep(time.Second)  //间隔1s再打印,防止一边插入数据一边打印时数据乱序

	for i, v := range s {

		fmt.Println(i, ":", v)

	}

}

func main() {

	m := make(map[int]int)

	go func() {				//开一个协程写map

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

			m[i] = i

		}

	}()



	go func() {				//开一个协程读map

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

			fmt.Println(m[i])

		}

	}()



	//time.Sleep(time.Second * 20)

	for {

		;

	}

}

var lock sync.Mutex

func main() {

	m:=make(map[int]int)

	go func() {			//开一个协程写map

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

			lock.Lock()				//加锁

			m[i]=i

			lock.Unlock()			//解锁

		}

	}()

	go func() {			//开一个协程读map

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

			lock.Lock()				//加锁

			fmt.Println(m[i])

			lock.Unlock()			//解锁

		}

	}()

	time.Sleep(time.Second*20)

}

1. 如果E1 Happens Before E2， 则E2 Happens After E1；
2. 如果E1 Happens E2， E2 Happens Before E3，则E1 Happens E3；
3. 如果 E1 和 E2没有任何Happens Before关系，则说E1和E2 Happen Concurrently。

1. E1 Happens Before E2；
2. 其他所有针对此内存的写操作，要么Happens Before E1，要么Happens After E2。也就是说不能存在其他的一个写操作E3，这个E3 Happens Concurrently E1/E2。

• 操作重排序。现代CPU通常是流水线架构，且具有多个核心，这样多条指令就可以同时执行。然而有时候出现一条指令需要等待之前指令的结果，或是其他造成指令执行需要延迟的情况。这个时候可以先执行下一条已经准备好的指令，以尽可能高效的利用CPU。操作重排序可以在两个阶段出现：

1. 编译器指令重排序
2. CPU乱序执行

• CPU 多核心间独立Cache Line的同步问题。多核CPU通常有自己的一级缓存和二级缓存，访问缓存的数据很快。但是如果缓存没有同步到主存和其他核心的缓存，其他核心读取缓存就会读到过期的数据。

// Sample Routine 1

func happensBeforeMulti(i int) {

	i += 2 // E1

	go func() { // G1 goroutine create

		fmt.Println(i) // E2

	}() // G2 goroutine destryo

}

1. 如果编译器或者CPU进行了重排序，那么E1的指令可能在E2之后执行，从而输出错误的值；
2. 变量i被CPU缓存到Cache Line中，E1对i的修改只改写了Cache Line，没有写回主存；而E2在另外的goroutine执行，如果和E1不是在同一个核上，那么E2输出的就是错误的值。

// Sample Routine 2

func happsBefore(i int, j int) {

	i += 2             // E1

	j += 10            // E2

	fmt.Println(i + j) //E3

}

• 对一个元素的send操作Happens Before对应的receive 完成操作
• 对channel的close操作Happens Before receive 端的收到关闭通知操作
• 对于Unbuffered Channel，对一个元素的receive 操作Happens Before对应的send完成操作
• 对于Buffered Channel，假设Channel 的buffer 大小为C，那么对第k个元素的receive操作，Happens Before第k+C个send完成操作。可以看出上一条Unbuffered Channel规则就是这条规则C=0时的特例

// Channel routine 1

var c = make(chan int)

var a string



func f() {

	a = "hello, world"

	<-c

}

func main() {

	go f()

	c <- 0

	print(a)

}

// Channel routine 2

var c = make(chan int, 10)

var a string



func f() {

	a = "hello, world"

	<-c

}

func main() {

	go f()

	c <- 0

	print(a)

}

// Channel routine 3

var c = make(chan int, 10)

var a string



func f() {

	a = "hello, world"

	c <- 0

}



func main() {

	go f()

	<-c

	print(a)

}

• 对于一个Mutex/RWMutex，设n < m，则第n个Unlock操作Happens Before第m个Lock操作。
• 对于一个RWMutex，存在数值n，RLock操作Happens After 第n个UnLock，其对应的RUnLockHappens Before 第n+1个Lock操作。

“泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念。”

“自然语言通常是指一种自然地随文化演化的语言。英语、汉语、日语为自然语言的例子，而世界语则为人造语言，即是一种由人蓄意为某些特定目的而创造的语言。 不过，有时所有人类使用的语言（包括上述自然地随文化演化的语言，以及人造语言） 都会被视为“自然”语言，以相对于如编程语言等为计算机而设的“人造”语言。这一种用法可见于自然语言处理一词中。自然语言是人类交流和思维的主要工具。 自然语言是人类智慧的结晶，自然语言处理是人工智能中最为困难的问题之一，而对自然语言处理的研究也是充满魅力和挑战的。 ”

“程序设计语言，programming language。用于书写计算机程序的语言。语言的基础是一组记号和一组规则。根据规则由记号构成的记号串的总体就是语言。在程序设计语言中，这些记号 串就是程序。程序设计语言有3个方面的因素，即语法、语义和语用。语法表示程序的结构或形式，亦即表示构成语言的各个记号之间的组合规律，但不涉及这些记 号的特定含义，也不涉及使用者。语义表示程序的含义，亦即表示按照各种方法所表示的各个记号的特定含义，但不涉及使用者。语用表示程序与使用者的关系。 ”

class Test<T>

{

    public T obj;

    public Set(T t)

    {

        this.obj = t;

    }

}