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

如果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)



}

• RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务
• 本地过程调用：如果需要将本地student对象的age+1，可以实现一个addAge()方法，将student对象传入，对年龄进行更新之后返回即可，本地方法调用的函数体通过函数指针来指定。
• 远程过程调用：上述操作的过程中，如果addAge()这个方法在服务端，执行函数的函数体在远程机器上，如何告诉机器需要调用这个方法呢？

// Client端 

//    Student student = Call(ServerAddr, addAge, student)

1. 将这个调用映射为Call ID。

2. 将Call ID，student（params）序列化，以二进制形式打包

3. 把2中得到的数据包发送给ServerAddr，这需要使用网络传输层

4. 等待服务器返回结果

5. 如果服务器调用成功，那么就将结果反序列化，并赋给student，年龄更新



// Server端

1. 在本地维护一个Call ID到函数指针的映射call_id_map，可以用Map<String, Method> callIdMap

2. 等待服务端请求

3. 得到一个请求后，将其数据包反序列化，得到Call ID

4. 通过在callIdMap中查找，得到相应的函数指针

5. 将student（params）反序列化后，在本地调用addAge()函数，得到结果

6. 将student结果序列化后通过网络返回给Client

• REST通常以业务为导向，将业务对象上执行的操作映射到HTTP动词，格式非常简单，可以使用浏览器进行扩展和传输，通过JSON数据完成客户端和服务端之间的消息通信，直接支持请求/响应方式的通信。不需要中间的代理，简化了系统的架构，不同系统之间只需要对JSON进行解析和序列化即可完成数据的传递。
• 但是REST也存在一些弊端，比如只支持请求/响应这种单一的通信方式，对象和字符串之间的序列化操作也会影响消息传递速度，客户端需要通过服务发现的方式，知道服务实例的位置，在单个请求获取多个资源时存在着挑战，而且有时候很难将所有的动作都映射到HTTP动词。
• 正是因为REST面临一些问题，因此可以采用gRPC作为一种替代方案，gRPC 是一种基于二进制流的消息协议，可以采用基于Protocol Buffer的IDL定义grpc API,这是Google公司用于序列化结构化数据提供的一套语言中立的序列化机制，客户端和服务端使用HTTP/2以Protocol Buffer格式交换二进制消息。
• gRPC的优势是，设计复杂更新操作的API非常简单，具有高效紧凑的进程通信机制，在交换大量消息时效率高，远程过程调用和消息传递时可以采用双向的流式消息方式，同时客户端和服务端支持多种语言编写，互操作性强；不过gRPC的缺点是不方便与JavaScript集成，某些防火墙不支持该协议。
• 注册中心：当项目中有很多服务时，可以把所有的服务在启动的时候注册到一个注册中心里面，用于维护服务和服务器之间的列表，当注册中心接收到客户端请求时，去找到该服务是否远程可以调用，如果可以调用需要提供服务地址返回给客户端，客户端根据返回的地址和端口，去调用远程服务端的方法，执行完成之后将结果返回给客户端。这样在服务端加新功能的时候，客户端不需要直接感知服务端的方法，服务端将更新之后的结果在注册中心注册即可，而且当修改了服务端某些方法的时候，或者服务降级服务多机部署想实现负载均衡的时候，我们只需要更新注册中心的服务群即可。

简单来说，embedding就是用一个低维的向量表示一个物体，可以是一个词，或是一个商品，或是一个电影等等。

injective （单射的）：就是我们所说的单射函数，每个X只有唯一的Y对应;
structure-preserving（结构保存）：比如在X所属的空间上 x1<=x2，那么映射后在Y所属空间上同理 y1 <= y2 。

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;

    }

}

1. 一个线程中的所有操作必定按照程序的顺序来执行。
2. 所有的线程都只能看到一个单一的执行顺序，不管是否同步。
3. 每个操作都必须原子执行且立即对所有程序可见。

是可以包含自由（未绑定到特定对象）变量的代码块，这些变量不在这个代码块内或者任何全局上下文中定义，而是在定义代码块的环境中定义。要执行的代码块（由于自由变量包含在代码块中，所以这些自由变量以及它们引用的对象没有被释放）为自由变量提供绑定的计算环境（作用域）。

闭包的价值在于可以作为函数对象或者匿名函数，对于类型系统而言，这意味着不仅要表示数据还要表示代码。支持闭包的多数语言都将函数作为第一级对象，就是说这些函数可以存储到变量中作为参数传递给其他函数，最重要的是能够被函数动态创建和返回。

package main

 

import "fmt"

/*

李逵和武松的Study方法的逻辑是几乎一模一样的

然而为了分别保存两人的学习进度，需要开辟两个全局变量，函数内部的需要使用两条分支结构才能完成业务逻辑

如果是108将都来学习。。。

此时代码的可复用性很差

*/

var progress int

func Study(name string, hours int) ( int) {

    fmt.Printf("%s学习了%d小时",name,hours)

    progress += hours

    return hours

}

func main081() {

    progress := Study("黑旋风",5)

    fmt.Printf("李逵的学习进度%d/10000",progress)

}

 

/*

使用闭包函数优化Study

每个人有不同的学习进度，将这个进度保存在【各自的闭包】中

*/

/*

闭包函数：返回函数的函数

闭包函数的好处：使用同一份内层函数的代码，创建出任意多个不同的函数对象，这些对象各自的状态都被保存在函数闭包（外层函数）中，各行其道，互不干扰

*/

 

func GetStudy(name string) func(int) int{

    var progress int

    study := func(hours int) int {

        fmt.Printf("%s学习了%d小时\n", name ,hours)

        progress += hours

        return progress

    }

    return study

}

 

func main() {

    studyFunc := GetStudy("李逵")

    studyFunc(3)

    studyFunc(5)

    likuiProgress := studyFunc(2)

    fmt.Printf("李逵的学习进度%d/10000\n",likuiProgress)

    studyFunc1 := GetStudy("宋江")

    studyFunc1(9)

    studyFunc1(8)

    songjiangProgress1 := studyFunc1(5)

    fmt.Printf("宋江的学习进度%d/10000\n",songjiangProgress1)

}

李逵学习了3小时

李逵学习了5小时

李逵学习了2小时

李逵的学习进度10/10000

宋江学习了9小时

宋江学习了8小时

宋江学习了5小时

宋江的学习进度22/10000

1. 构建优先队列
2. 支持堆排序
3. 快速找出一个集合中的最小值（或者最大值）
4. 在朋友面前装逼

注意：堆的根节点中存放的是最大或者最小元素，但是其他节点的排序顺序是未知的。例如，在一个最大堆中，最大的那一个元素总是位于 index 0 的位置，但是最小的元素则未必是最后一个元素。--唯一能够保证的是最小的元素是一个叶节点，但是不确定是哪一个。

[ 10, 7, 2, 5, 1 ]

parent(i) = floor((i - 1)/2)

left(i)   = 2i + 1

right(i)  = 2i + 2

注意：根节点(10)没有父节点，因为 -1 不是一个有效的数组索引。同样，节点 (2)，(5)和(1) 没有子节点，因为这些索引已经超过了数组的大小，所以我们在使用这些索引值的时候需要保证是有效的索引值。

array[parent(i)] >= array[i]

注意：你可以使用普通树来模拟堆，但是那对空间是极大的浪费。

package main



import (

    "bytes"

    "fmt"

    "encoding/gob"

    "io"

)



//准备编码的数据

type P struct {

    X, Y, Z int

    Name    string

}



//接收解码结果的结构

type Q struct {

    X, Y *int32

    Name string

}



func main() {

    //初始化一个数据

    data := P{3, 4, 5, "CloudGeek"}

    //编码后得到buf字节切片

    buf := encode(data)

    //用于接收解码数据

    var q *Q

    //解码操作

    q = decode(buf)

    //"CloudGeek": {3,4}

    fmt.Printf("%q: {%d,%d}\n", q.Name, *q.X, *q.Y)



}



func encode(data interface{}) *bytes.Buffer {

    //Buffer类型实现了io.Writer接口

    var buf bytes.Buffer

    //得到编码器

    enc := gob.NewEncoder(&buf)

    //调用编码器的Encode方法来编码数据data

    enc.Encode(data)

    //编码后的结果放在buf中

    return &buf

}



func decode(data interface{}) *Q {

    d := data.(io.Reader)

    //获取一个解码器，参数需要实现io.Reader接口

    dec := gob.NewDecoder(d)

    var q Q

    //调用解码器的Decode方法将数据解码，用Q类型的q来接收

    dec.Decode(&q)

    return &q

}

package main



import (

    "encoding/gob"

    "os"

    "fmt"

)



//试验用的数据类型

type Address struct {

    City    string

    Country string

}



//序列化后数据存放的路径

var filePath string



func main() {

    filePath = "./address.gob"

    encode()

    pa := decode()

    fmt.Println(*pa) //{Chengdu China}

}



//将数据序列号后写到文件中

func encode() {

    pa := &Address{"Chengdu", "China"}

    //打开文件，不存在的时候新建

    file, _ := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY, 0666)

    defer file.Close()



    //encode后写到这个文件中

    enc := gob.NewEncoder(file)

    enc.Encode(pa)

}



//从文件中读取数据并反序列化

func decode() *Address {

    file, _ := os.Open(filePath)

    defer file.Close()



    var pa Address

    //decode操作

    dec := gob.NewDecoder(file)

    dec.Decode(&pa)

    return &pa

}