select

golang 的 select 就是监听 IO 操作，当 IO 操作发生时，触发相应的动作。 
在执行select语句的时候，运行时系统会自上而下地判断每个case中的发送或接收操作是否可以被立即执行【立即执行：意思是当前Goroutine不会因此操作而被阻塞，还需要依据通道的具体特性(缓存或非缓存)】

• 每个case语句里必须是一个IO操作
• 所有channel表达式都会被求值、所有被发送的表达式都会被求值
• 如果任意某个case可以进行，它就执行(其他被忽略)。
• 如果有多个case都可以运行，Select会随机公平地选出一个执行(其他不会执行)。
• 如果有default子句，case不满足条件时执行该语句。
• 如果没有default字句，select将阻塞，直到某个case可以运行；Go不会重新对channel或值进行求值。

select 语句用法

注意到 select 的代码形式和 switch 非常相似， 不过 select 的 case 里的操作语句只能是【IO 操作】 。 
此示例里面 select 会一直等待等到某个 case 语句完成， 也就是等到成功从 ch1 或者 ch2 中读到数据,如果都不满足条件且存在default case, 那么default case会被执行。 则 select 语句结束。 
示例：

package main  import (     "fmt" )  func main(){     ch1 := make(chan int, 1)     ch2 := make(chan int, 1)      select {         case e1 := <-ch1:         //如果ch1通道成功读取数据，则执行该case处理语句             fmt.Printf("1th case is selected. e1=%v",e1)         case e2 := <-ch2:         //如果ch2通道成功读取数据，则执行该case处理语句             fmt.Printf("2th case is selected. e2=%v",e2)         default:         //如果上面case都没有成功，则进入default处理流程             fmt.Println("default!.")     } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

select分支选择规则

所有跟在case关键字右边的发送语句或接收语句中的通道表达式和元素表达式都会先被求值。无论它们所在的case是否有可能被选择都会这样。

求值顺序：自上而下、从左到右 
示例：

package main  import (     "fmt" ) //定义几个变量，其中chs和numbers分别代表了包含了有限元素的通道列表和整数列表 var ch1 chan int var ch2 chan int var chs = []chan int{ch1, ch2} var numbers = []int{1,2,3,4,5}  func main(){     select {         case getChan(0) <- getNumber(2):             fmt.Println("1th case is selected.")         case getChan(1) <- getNumber(3):             fmt.Println("2th case is selected.")         default:             fmt.Println("default!.")     } }  func getNumber(i int) int {     fmt.Printf("numbers[%d]\n", i)     return numbers[i] }  func getChan(i int) chan int {     fmt.Printf("chs[%d]\n", i)     return chs[i] }
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
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

输出：

chs[0] 
numbers[2] 
chs[1] 
numbers[3] 
default!.

可以看出求值顺序。满足自上而下、自左而右这条规则。

随机执行case

如果同时有多个case满足条件，通过一个伪随机的算法决定哪一个case将会被执行。 
示例：

package main  import (     "fmt" ) func main(){     chanCap := 5     ch7 := make(chan int, chanCap)      for i := 0; i < chanCap; i++ {         select {             case ch7 <- 1:             case ch7 <- 2:             case ch7 <- 3:         }     }      for i := 0; i < chanCap; i++ {         fmt.Printf("%v\n", <-ch7)     } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出：(注：每次运行都会不一样)

3 
3 
2 
3 
1

一些惯用手法示例

示例一：单独启用一个Goroutine执行select,等待通道关闭后结束循环

package main  import (     "fmt"     "time" ) func main(){     //初始化通道     ch11 := make(chan int, 1000)     sign := make(chan int, 1)      //给ch11通道写入数据     for i := 0; i < 1000; i++ {         ch11 <- i     }     //关闭ch11通道     close(ch11)      //单独起一个Goroutine执行select     go func(){         var e int         ok := true          for{             select {                 case e,ok = <- ch11:                 if !ok {                     fmt.Println("End.")                     break                 }                 fmt.Printf("ch11 -> %d\n",e)             }              //通道关闭后退出for循环             if !ok {                 sign <- 0                 break             }         }      }()      //惯用手法，读取sign通道数据，为了等待select的Goroutine执行。     <- sign }
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
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

ch11 -> 0 
ch11 -> 1 
… 
ch11 -> 999 
End.

示例二：加以改进，我们不想等到通道被关闭后再退出循环，利用一个辅助通道模拟出操作超时。

package main  import (     "fmt"     "time" ) func main(){     //初始化通道     ch11 := make(chan int, 1000)     sign := make(chan int, 1)      //给ch11通道写入数据     for i := 0; i < 1000; i++ {         ch11 <- i     }     //关闭ch11通道     close(ch11)      //我们不想等到通道被关闭之后再推出循环，我们创建并初始化一个辅助的通道，利用它模拟出操作超时行为     timeout := make(chan bool,1)     go func(){         time.Sleep(time.Millisecond) //休息1ms         timeout <- false     }()      //单独起一个Goroutine执行select     go func(){         var e int         ok := true          for{             select {                 case e,ok = <- ch11:                     if !ok {                         fmt.Println("End.")                         break                     }                     fmt.Printf("ch11 -> %d\n",e)                 case ok = <- timeout:                 //向timeout通道发送元素false后，该case几乎马上就会被执行, ok = false                     fmt.Println("Timeout.")                     break             }             //终止for循环             if !ok {                 sign <- 0                 break             }         }      }()      //惯用手法，读取sign通道数据，为了等待select的Goroutine执行。     <- sign }
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
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

ch11 -> 0 
ch11 -> 1 
… 
ch11 -> 691 
Timeout.

示例三：上面实现了单个操作的超时,但是那个超时触发器开始计时有点早。

package main  import (     "fmt"     "time" ) func main(){     //初始化通道     ch11 := make(chan int, 1000)     sign := make(chan int, 1)      //给ch11通道写入数据     for i := 0; i < 1000; i++ {         ch11 <- i     }     //关闭ch11通道     //close(ch11),为了看效果先注释掉      //单独起一个Goroutine执行select     go func(){         var e int         ok := true          for{             select {                 case e,ok = <- ch11:                     if !ok {                         fmt.Println("End.")                         break                     }                     fmt.Printf("ch11 -> %d\n",e)                 case ok = <- func() chan bool {                     //经过大约1ms后，该接收语句会从timeout通道接收到一个新元素并赋值给ok,从而恰当地执行了针对单个操作的超时子流程，恰当地结束当前for循环                     timeout := make(chan bool,1)                     go func(){                         time.Sleep(time.Millisecond)//休息1ms                         timeout <- false                     }()                     return timeout                 }():                     fmt.Println("Timeout.")                     break             }             //终止for循环             if !ok {                 sign <- 0                 break             }         }      }()      //惯用手法，读取sign通道数据，为了等待select的Goroutine执行。     <- sign }
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
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

ch11 -> 0 
ch11 -> 1 
… 
ch11 -> 999 
Timeout.

非缓冲的Channel

我们在初始化一个通道时将其容量设置成0，或者直接忽略对容量的设置，那么就称之为非缓冲通道

ch1 := make(chan int, 1) //缓冲通道 ch2 := make(chan int, 0) //非缓冲通道 ch3 := make(chan int) //非缓冲通道
1
2
3
1
2
3

• 向此类通道发送元素值的操作会被阻塞，直到至少有一个针对该通道的接收操作开始进行为止。
• 从此类通道接收元素值的操作会被阻塞，直到至少有一个针对该通道的发送操作开始进行为止。
• 针对非缓冲通道的接收操作会在与之相应的发送操作完成之前完成。

对于第三条要特别注意，发送操作在向非缓冲通道发送元素值的时候，会等待能够接收该元素值的那个接收操作。并且确保该元素值被成功接收，它才会真正的完成执行。而缓冲通道中，刚好相反，由于元素值的传递是异步的，所以发送操作在成功向通道发送元素值之后就会立即结束(它不会关心是否有接收操作)。

示例一

实现多个Goroutine之间的同步

package main  import (     "fmt"     "time" )  func main(){     unbufChan := make(chan int)     //unbufChan := make(chan int, 1) 有缓冲容量      //启用一个Goroutine接收元素值操作     go func(){         fmt.Println("Sleep a second...")         time.Sleep(time.Second)//休息1s         num := <- unbufChan //接收unbufChan通道元素值         fmt.Printf("Received a integer %d.\n", num)     }()      num := 1     fmt.Printf("Send integer %d...\n", num)     //发送元素值     unbufChan <- num     fmt.Println("Done.") }
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
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

缓冲channel输出结果如下： 
Send integer 1… 
Done. 
====================== 
非缓冲channel输出结果如下： 
Send integer 1… 
Sleep a second… 
Received a integer 1. 
Done.

在非缓冲Channel中，从打印数据可以看出主Goroutine中的发送操作在等待一个能够与之配对的接收操作。配对成功后，元素值1才得以经由unbufChan通道被从主Goroutine传递至那个新的Goroutine.

select与非缓冲通道

与操作缓冲通道的select相比，它被阻塞的概率一般会大很多。只有存在可配对的操作的时候，传递元素值的动作才能真正的开始。 
示例：

发送操作间隔1s,接收操作间隔2s 
分别向unbufChan通道发送小于10和大于等于10的整数，这样更容易从打印结果分辨出配对的时候哪一个case被选中了。下列案例两个case是被随机选择的。

package main  import (     "fmt"     "time" )  func main(){     unbufChan := make(chan int)     sign := make(chan byte, 2)      go func(){         for i := 0; i < 10; i++ {             select {                 case unbufChan <- i:                 case unbufChan <- i + 10:                 default:                     fmt.Println("default!")             }             time.Sleep(time.Second)         }         close(unbufChan)         fmt.Println("The channel is closed.")         sign <- 0     }()      go func(){         loop:             for {                 select {                     case e, ok := <-unbufChan:                     if !ok {                         fmt.Println("Closed channel.")                         break loop                     }                     fmt.Printf("e: %d\n",e)                     time.Sleep(2 * time.Second)                 }             }             sign <- 1     }()     <- sign     <- sign }
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
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

default! //无法配对 
e: 1 
default!//无法配对 
e: 3 
default!//无法配对 
e: 15 
default!//无法配对 
e: 17 
default!//无法配对 
e: 9 
The channel is closed. 
Closed channel.

default case会在收发操作无法配对的情况下被选中并执行。在这里它被选中的概率是50%。

• 上面的示例给予了我们这样一个启发：使用非缓冲通道能够让我们非常方便地在接收端对发送端的操作频率实施控制。
• 可以尝试去掉default case，看看打印结果，代码稍作修改如下：

package main  import (     "fmt"     "time" )  func main(){     unbufChan := make(chan int)     sign := make(chan byte, 2)      go func(){         for i := 0; i < 10; i++ {             select {                 case unbufChan <- i:                 case unbufChan <- i + 10:              }             fmt.Printf("The %d select is selected\n",i)             time.Sleep(time.Second)         }         close(unbufChan)         fmt.Println("The channel is closed.")         sign <- 0     }()      go func(){         loop:             for {                 select {                     case e, ok := <-unbufChan:                     if !ok {                         fmt.Println("Closed channel.")                         break loop                     }                     fmt.Printf("e: %d\n",e)                     time.Sleep(2 * time.Second)                 }             }             sign <- 1     }()     <- sign     <- sign }
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
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

e: 0 
The 0 select is selected 
e: 11 
The 1 select is selected 
e: 12 
The 2 select is selected 
e: 3 
The 3 select is selected 
e: 14 
The 4 select is selected 
e: 5 
The 5 select is selected 
e: 16 
The 6 select is selected 
e: 17 
The 7 select is selected 
e: 8 
The 8 select is selected 
e: 19 
The 9 select is selected 
The channel is closed. 
Closed channel.

总结：上面两个例子，第一个有default case 无法配对时执行该语句，而第二个没有default case ，无法配对case时select将阻塞，直到某个case可以运行(上述示例是直到unbufChan数据被读取操作)，不会重新对channel或值进行求值。

 golang 的 select 的功能和 select, poll, epoll 相似， 就是监听 IO 操作，当 IO 操作发生时，触发相应的动作。

示例：

ch1 := make (chan int, 1) ch2 := make (chan int, 1)  ...  select { case <-ch1:     fmt.Println("ch1 pop one element") case <-ch2:     fmt.Println("ch2 pop one element") } 

注意到 select 的代码形式和 switch 非常相似， 不过 select 的 case 里的操作语句只能是【IO 操作】 。

此示例里面 select 会一直等待等到某个 case 语句完成， 也就是等到成功从 ch1 或者 ch2 中读到数据。 则 select 语句结束。

【使用 select 实现 timeout 机制】

如下：

timeout := make (chan bool, 1) go func() {     time.Sleep(1e9) // sleep one second     timeout <- true }() ch := make (chan int) select { case <- ch: case <- timeout:     fmt.Println("timeout!") } 

当超时时间到的时候，case2 会操作成功。 所以 select 语句则会退出。 而不是一直阻塞在 ch 的读取操作上。 从而实现了对 ch 读取操作的超时设置。

下面这个更有意思一点。

当 select 语句带有 default 的时候：

ch1 := make (chan int, 1) ch2 := make (chan int, 1)  select { case <-ch1:     fmt.Println("ch1 pop one element") case <-ch2:     fmt.Println("ch2 pop one element") default:     fmt.Println("default") } 

此时因为 ch1 和 ch2 都为空，所以 case1 和 case2 都不会读取成功。 则 select 执行 default 语句。

就是因为这个 default 特性， 我们可以使用 select 语句来检测 chan 是否已经满了。

如下：

ch := make (chan int, 1) ch <- 1 select { case ch <- 2: default:     fmt.Println("channel is full !") } 

因为 ch 插入 1 的时候已经满了， 当 ch 要插入 2 的时候，发现 ch 已经满了（case1 阻塞住）， 则 select 执行 default 语句。 这样就可以实现对 channel 是否已满的检测， 而不是一直等待。

比如我们有一个服务， 当请求进来的时候我们会生成一个 job 扔进 channel， 由其他协程从 channel 中获取 job 去执行。 但是我们希望当 channel 瞒了的时候， 将该 job 抛弃并回复 【服务繁忙，请稍微再试。】 就可以用 select 实现该需求。

关于垃圾回收

c++ 写久了的人， 刚接触 golang 的时候最不能理解的就是为什么作者要支持垃圾回收。 不管是从垃圾回收器的实现上看， 还是对于程序员编程习惯的养成方面， 都避免不了编写出的程序性能损失。 但是写了几天 golang 之后， 又觉得有垃圾回收确实大大减轻程序员的心智负担， 降低编程门槛，提高编程效率。 让我联想到 汇编 和 C语言 的关系， 即使 C语言的性能不如汇编写出来的高， 但是后者还是颠覆了前者。

 刚才看golang的sync的包，看见一个很有用的功能。就是WaitGroup。

先说说WaitGroup的用途：它能够一直等到所有的goroutine执行完成，并且阻塞主线程的执行，直到所有的goroutine执行完成。

这里要注意一下，他们的执行结果是没有顺序的，调度器不能保证多个 goroutine 执行次序，且进程退出时不会等待它们结束。

WaitGroup总共有三个方法：Add(delta int),Done(),Wait()。简单的说一下这三个方法的作用。

Add:添加或者减少等待goroutine的数量

Done:相当于Add(-1)

Wait:执行阻塞，直到所有的WaitGroup数量变成0

如：

golang中的同步是通过sync.WaitGroup来实现的．WaitGroup的功能：它实现了一个类似队列的结构，可以一直向队列中添加任务，当任务完成后便从队列中删除，如果队列中的任务没有完全完成，可以通过Wait()函数来出发阻塞，防止程序继续进行，直到所有的队列任务都完成为止．

WaitGroup的特点是Wait()可以用来阻塞直到队列中的所有任务都完成时才解除阻塞，而不需要sleep一个固定的时间来等待．但是其缺点是无法指定固定的goroutine数目．但是其缺点是无法指定固定的goroutine数目．可能通过使用channel解决此问题。

另一个例子：

http://studygolang.com/articles/2027

 SSDP 简单服务发现协议，是应用层协议，是构成UPnP（通用即插即用）技术的核心协议之一。它为网络客户端（network client）提供了一种发现网络服务（network services）的机制，采用基于通知和发现路由的多播方式实现。

SSDP多播地址：239.255.255.250:1900（IPv4），FF0x::C（IPv6）

两种类型的SSDP请求消息会通过SSDP多播地址发送：

1. 发现请求（Discovery request 或查询请求）。SSDP客户端向此地址发送HTTP UDP 发现请求，查询某种类型的服务。SSDP服务在此地址上监听服务发现请求。当服务监听到的HTTP UDP 发现请求和它自己提供的服务匹配时，它以单播方式发送HTTP UDP 响应。

2. 存在通知（notification）。SSDP服务向此多播地址发送HTTP UDP 通知消息来宣布自己的存在。

发现结果（discovery results）和存在通知消息（presence announcements）提供的信息包括：

服务的类型URI

服务名称USN：唯一标识一种服务实例。

位置信息：发现结果和存在通知可包含一个或多个位置URI，客户端利用位置信息可以找到它需要的服务。

期限信息：客户端在自己的cache中保存此服务多长时间。如果期限过了，关于此服务的信息会被从cache中拿掉。当客户端接收到的发现结果或存在通知包含的USN和cache中的某条匹配，则更新。

客户端的服务缓存像下面这样：

【SSDP发现请求】ssdp:discover

ssdp:discover 必须包含一个ST头，客户端使用ST头来表明他们想发现的服务类型。ssdp:discover 必须包含一个带 *  的请求URI。

M-SEARCH * HTTP/1.1

S: uuid:ijklmnop-7dec-11d0-a765-00a0c91e6bf6

Host: 239.255.255.250:1900

Man: "ssdp:discover"

ST: ge:fridge

MX: 3

各HTTP协议头的含义：

HOST：设置为协议保留多播地址和端口，必须是：239.255.255.250:1900（IPv4）或FF0x::C(IPv6)

MAN：设置协议查询的类型，必须是：ssdp:discover

MX：设置设备响应最长等待时间。设备响应在0和这个值之间随机选择响应延迟的值，这样可以为控制点响应平衡网络负载。

ST：设置服务查询的目标，它必须是下面的类型：

-ssdp:all 搜索所有设备和服务

-upnp:rootdevice 仅搜索网络中的根设备

-uuid:device-UUID 查询UUID标识的设备

-urn:schemas-upnp-org:device:device-Type:version 查询device-Type字段指定的设备类型，设备类型和版本由UPNP组织定义。

-urn:schemas-upnp-org:service:service-Type:version 查询service-Type字段指定的服务类型，服务类型和版本由UPNP组织定义。

SSDP服务发现自己的服务类型和ST中指明的服务类型匹配时，可以向ssdp:discover来自的IP地址/端口响应。响应消息应该包含服务的位置信息（Location 或AL头），ST和USN头。响应消息应该包含cache控制信息（max-age 或者 Expires头），如果两者都包含了，Expires 头优先，如果两者都缺失，那么这条服务消息不能被cache。

HTTP/1.1 200 OK

S: uuid:ijklmnop-7dec-11d0-a765-00a0c91e6bf6

Ext:

Cache-Control: no-cache="Ext", max-age = 5000

ST: ge:fridge

USN: uuid:abcdefgh-7dec-11d0-a765-00a0c91e6bf6

AL: <blender:ixl><http://foo/bar>

各HTTP协议头的含义简介：

CACHE-CONTROL：max-age指定通知消息存活时间，如果超过此时间间隔，控制点可以认为设备不存在

DATE：指定响应生成的时间

EXT：向控制点确认MAN头域已经被设备理解

LOCATION：包含根设备描述得URL地址

SERVER：饱含操作系统名，版本，产品名和产品版本信息

ST：内容和意义与查询请求的相应字段相同

USN：表示不同服务的统一服务名，它提供了一种标识出相同类型服务的能力。

【SSDP存在通知消息】

SSDP服务通过存在通知消息来向客户端宣布自己的存在，更新期限信息，更新位置信息。

ssdp:alive 消息必须将 NT 设置成自己的服务类型，USN头设置成自己的USN。ssdp:alive 应该包括Location或者AL头，如果没有DNS支持的话，使用SSDP服务的IP地址来代表位置。ssdp:alive还应该包括cache控制信息，max-age或者Expires头。

NOTIFY * HTTP/1.1

Host: 239.255.255.250:reservedSSDPport

NT: blenderassociation:blender

NTS: ssdp:alive

USN: someunique:idscheme3

AL: <blender:ixl><http://foo/bar>

Cache-Control: max-age = 7393

ssdp:alive 没有响应消息。

SSDP服务可以发送ssdp:byebye 来宣布自己下线。ssdp:byebye 必须将NT设置成自己的服务类型，将USN头设置成自己的USN。ssdp:byebye 也没有响应消息。当客户端接收到ssdp:byebye 消息，删掉cache里面的相关条目。

NOTIFY * HTTP/1.1

Host: 239.255.255.250:reservedSSDPport

NT: someunique:idscheme3

NTS: ssdp:byebye

USN: someunique:idscheme3

【SSDP Auto-Shut-Off Algorithm】

A mechanism is needed to ensure that SSDP does not cause such a high level of traffic that it overwhelms the network it is running on.

【ssdp:all】

A mechanism is needed to enable a client to enumerate all the services available on a particular SSDP multicast channel/port.

【参考】

SSDP 协议原文：http://tools.ietf.org/html/draft-cai-ssdp-v1-03

http://www.cnblogs.com/debin/archive/2009/12/01/1614543.html

 SSDP协议基础详解

 区块链的技术发展一日千里，几乎每天都有区块链技术或应用的新消息和进展，每个月都有新的区块链相关技术出来，各类区块链技术体系层出不穷，除了Elwin在《区块链主流开源技术体系介绍》提到的目前几大主流的开源区块链技术体系（包括比特币体系、以太坊、fabric、比特股、公证通、瑞波、未来币、锯齿湖、布比、小蚁等技术体系介绍，有兴趣可以搜索旧文看看）在不断完善发展外，市场上很快又涌现了很多新生代的区块链技术体系，本文将会一一进行介绍。

一、恒星网络

恒星网络，stellar，一个由前瑞波(Ripple)创始人Jed McCaleb发起的区块链接项目，用于搭建一个数字货币与法定货币之间传输的去中心化网关。最近，乐视金融与恒星基金会签约，共建NBiLe与Lumens两个平行网络，实现通缩与通胀并行。

恒星网络是基于Ripple基础上进行开发，在比特币和瑞波的技术基础上做了的很多改进，特别是相关的共识机制和验证算法，恒星网络运行节点性能得到提高，并节点资源需求非常低。众多改进其中，最大改动的是恒星支付系统的支撑算法SCP（恒星共识协议），号称是目前最安全的类拜占庭算法。SCP共识机制应用“集合块”，即各节点选择其可信任的其他节点。所有这些个体选择之和便是系统层面的共识集合。这些集合块将整个系统联结起来，正如个体网络的决策统一了互联网一样。SCP对计算能力以及经济成本消耗要求适度，降低了进入门槛并潜在地把金融系统开放给新的参与者，同时也是一种最佳的对抗恶性行为参与者使得系统恢复的构建方法。

开源代码地址为https://github.com/stellar/stellar-core，系统主要开发语言为C++，共识机制为SCP，支持智能合约，适用于公链和联盟链。

二、Tendermint

美国公司推出的Tendermint作为第二代区块链架构，已经超越了受限制的基于代币/类比特币的单片系统，是第一个实施分片技术的公共区块链。

Tendermint是一种开源的区块链套接字协议，消除了区块链之前的复杂性，为区块链开发提供了模块化结构，并且在区块链核心提供了一个开源的区块链引擎，使得各种机构和开发团队都能够轻松且高效地创建属于他们自己的区块链技术。Tendermint主核心将会管理所有的区块链分区，你可以有比特币分区或以太坊分区，具有很大的灵活性。在Tendermint平台上可以搭建基于任何编程语言的应用开发界面，主核心管理所有分片，分片包含很多类型，可以是比特币分片、或者以太坊分片。

Tendermint共识引擎通过Tendermint套接字协议（TMSP）与应用程序进行连接。Tendermint通过在应用程序进程和共识形成过程之间设置一个非常简单的应用程序接口，可以对区块链设计进行分解。并且TMSP不依赖于某一特定的编程语言，所以开发人员可以使用任意一种编程语言来编写智能合约。用户同样还能够利用现有的代码库，工作流和开发生态系统来创建复杂的应用程序。

开源代码地址为https://github.com/tendermint/tendermint，系统主要开发语言为GO，所使用的是拜占庭容错共识机制，支持智能合约，具有去中心化控制、低延时、渐进安全的特效，大大提高扩展性和速度，每秒钟可以完成超过10,000笔交易，适用于公链和联盟链、私链。

三、Openchain

Openchain是由区块链技术公司Coinprism开源分布式总账区块链工具，主要提供给大型企业和金融机构，Openchain 在处理大型企业和金融机构的数据的时候，相较于传统的区块链工具，能大大的降低计算速度，并能降低成本和交易方风险。

不同于比特币，Openchain基于一种独特的分布式账本技术，它可帮助用户部署自己版本的区块链，减少用户的交易成本和结算时间。Openchain去除了区块，交易和交易之间直接连通，这意味着交易可以得到即时确认。任何人都可以连接到一个验证的节点，并收到一份交易验证的实时复制本，Openchain还通过数字签名来保护交易的安全性，使交易不可伪造。另外，通过挂钩模块，基于Openchain的token可以作为侧链挂钩到比特币网络上。

开源代码地址为https://github.com/openchain/，系统主要开发语言为C#开发，他是DNX应用，可以支持跨平台运行，支持智能合约，适用于联盟链。

四、多链MultiChain

多链Multichain，他是一个区块链软件平台，任何人都可以在上面创建和部署私链（permission chain）。隐私与控制的争议是比特币成为行业性金融机构的障碍，而用MultiChain创建的私有链则克服了这个困难。Multichain支持快速部署，两步就可以生成自已的区块链，三步就可以连接上其它区块链。

MultiChain是采用PoW共识机制，通过对用户权限的综合管理解决了挖矿，隐私和公开性问题。MultiChain提供了一种创新性的可信决策网络实体的方法来解决私有区块链的挖矿问题。该平台可将挖矿活动限制在一套可供验证的实体内，并且避免了单一方对挖矿过程的垄断。这种被成为“多样性挖矿”的方案通过限定给定窗口内同一矿工的区块数量来解决挖矿问题。“多样性挖矿”取消了工作量证明的重要性和本地加密货币的必要性，并且可使处理交易的矿工以随机轮转的方式认可交易。

MultiChain向后兼容比特币，因此用户能够把现存的比特币应用导入到 MultiChain。不是支持像比特币内核的单一链， MultiChain可被配置以同时支持同一网络的不同区块链。MultiChain能够支持很多第三方资产，能够使私有区块链和比特币区块链相互转换。

MultiChain开源代码即将发布中。

五、Corda

R3的区块链软件Corda，旨在为参与其中的70多家银行研发解决方案，专为金融服务所设计的新分散式的分类帐平台。他号称自己不是区块链，而用以记录和管理金融合约的分布式账本。但Elwin认为，Cordar的系统核心还是是基于区块链技术的，他包含区块链的五大特性，共识、有效性、唯一性、不可更改性和认证，Corda採用许多区块链技术的优势与特性，同时捨弃掉让区块链技术无法融进大多数金融领域的设计理念，排除了一些不适合银行业应用场景的设计思路。

Corda平台基于产业标准工具所打造，不包含原生虚拟货币，主要特性包括能可支援各种共识机制、自动编排跨组织之间的工作流，不需仰赖单一中心化的控制机构，Corda用非常精确的时间界限来处理交易而非区块挖掘时平均大致的时间界限，且能直接设计出负责监管与监督观察作业的节点，并经由特定交易方来验证，不需由一大群与该交易无关的验证者。

Corda在智能合约，数据处理等方面也做了创新，而且也符合通过协作以保持金融数据协议的准确和共享。自然隐私和监管也在它的专用平台设计之中。Corda关注可互操作性和增量部署，不对第三方泄露机密信息。公司可以查看与对手方达成的协议，并确保双方看到的信息一致并向监管机构报备。Corda系统引入了法律语言体系，并包含管理金融协议的作用，该系统必须使企业逻辑编写简单化并与现有代码兼容，还必须支持协议相关企业间的行为协调。

针对金融使用场景和面向银行为主要使用者，Corda系统主要特点：

l   没有多余的全局数据共享：只有有合法需求的参与方可以按照协议获取数据；

l   Corda编写和配置在企业间流转，无中心控制者；

l   Corda在企业间单个交易水平达成共识，而不是在系统水平上；

l   系统设计直接支持监管观察员节点；

l   交易直接由交易双方验证，而不是由一大群不相干的验证者进行；

l   支持多种共识机制；

l   记录了智能合约代码和人类语言法律文件的清晰联系；

l   用行业标准工具创建；

l   没有原始加密货币。

Corda适用于联盟链，特别为金融业务打造，下个月将发布开源代码。

六、龙链

龙链（Dragonchain）是迪士尼打造的，他是将其混合公有/私有区块链的区块链平台。

龙链是另一种用来保持记录和处理交易的区块链。它与比特币的底层技术十分相似，但又有一点不同。龙链是一种多币制的区块链，节点就可以随之定义一种货币并支持其使用。该网络上可以同时使用多种货币。龙链的共识机制可以支持一种或多种现有的共识机制（Trust，PoW，PoS），甚至是可以支持自己定义和创建一种新的共识机制。

龙链的目标特性：

l   易于集成现有的系统

l   便于传统的工程师和程序员开发，不一定需要熟悉的区块链、分布式系统和密码密码学技术

l   C/S客户服务器方式和RESTful方式集成

l   简单灵活的架构

l   默认情况下提供对业务数据的保护

l   允许业务集中控制过程

l   固定长度和周期，短和高速的区块

l   多货币支持

l   没有基础货币

l   与其他公共和私人blockchains的互操作性

开源代码地址为https://github.com/dragonchain/dragonchain，系统主要开发语言是Python，支持智能合约，适合联盟链和私链。

七、量子链

量子链Qtum是中国社区原创的区块链公链。Qtum通过价值传输协议（Value Transfer Protocol）来实现点对点的价值转移，并根据此协议，构建一个支持多个行业的（金融、物联网、供应链、社交游戏等）去中心化的应用开发平台（DAPP Platform）。

量子链的定位是，做一个符合行业监管的区块链去中心化应用开发平台。为了符合以后的行业监管，量子链团队在设计的时候，为监管者的角色设计了很多可选项，引入数字身份和第三方征信平台，设计一种新的合约类型—主控合约，把监管者的角色引入，同时监管者可以作为 Qtum系统中的喻言和数据源的提供者。

量子链采用可插拔的共识机制：Qtum系统包括 Qtum 公链和Qtum联盟链，因为网络环境和参与者的不同，考虑到公链的去中心化程度、参与门槛、安全性和可靠性，量子链开发团队采用IPOS（Incentive Proof of Stake）机制作为区块链网络的共识机制。因为联盟链大多参与者都是受限的节点、身份已知的对手方，对共识机制的考量不同于公链网络，在联盟链中，量子链将采取Proof of Time 和Raft结合的共识协议，实现高速的区块链共识网络。

Qtum的开源代码地址Elwin未找到，支持EVM的虚拟机（EVM/EVM2.0），支持智能合约，适合公链和联盟链。

八、Chain

Chain是由一家刚成立两年的美国创业公司Chain推出，是一个企业级的区块链平台架构，可以让机构构造从零开始更好的金融服务。

作为区块链供应商，Chain在过去的两年多时间中获得了极好的信用。Chain通过将专属区块链和分布式总账的源代码进行开放，可以让更多的人在其软件上增加应用或是建立专属网络。Chain核心开发者版本的创建花费了数年时间，它是区块链供应商和金融机构合作的直接产物。由于这个开源软件针对的是金融领域，因此它允许用户创建和发行他们自己认为合适的数字资产。

Chain 开放标准在以下方面实现突破：

l   全新的共识模型在不到一秒的时间里实现交易的最终完成，即便是交易量非常大也能支持

l   私密解决方案对区块链数据进行加密，并让相关对手方和监管者进行有选择的读取

l   智能合约框架和虚拟机支持简单的规则执行，以及进行键值存储的图灵完整程序

l   可伸缩的数据模型可以为网络参与者降低运行负荷

l   丰富的元数据层可支持满足KYC（了解你的客户）和 AML（反洗钱）要求

开源代码地址为https://github.com/chain/chain，系统主要开发语言是GO，共识协议采用联邦拜占庭协议，支持多种数字资产，适合联盟链。

 共识（Consensus）过程是一个非常有趣的过程。

在我们的日常生活中，几乎所有的事情都是达成共识的过程。

达成共识越分散的过程，其效率就越低，但满意度越高，因此也越稳定；相反，达成共识越集中的过程，效率越高，也越容易出现独裁和腐败现象。

• 达成共识常用的一种方法就是通过物质上的激励以对某个事件达成共识；但是这种共识存在的问题就是容易被外界其它更大的物质激励所破坏。

• 还有一种就是群体中的个体按照符合自身利益或整个群体利益的方向来对某个事件自发地达成共识；当然形成这种自发式的以维护群体利益为核心的共识过程还是需要时间和环境因素的，但是一旦达成这样的共识趋势，其共识结果也越稳定，越不容易被破坏。

在比特币和其它区块链币中，也存在如何达成共识的问题。或者说，比特币或其它区块链币最核心的问题也是如何在去中心化的环境中达成共识。

区块链是比特币背后的核心技术，也是支撑比特币的基础架构。因此在谈区块链共识，就必然要谈比特币的共识。

比特币最核心的突破是在去中心化的情况下对交易事件达成了共识，即在没有中心组织的情况下对某个交易的有效性达成了一致。

比特币实现这个共识的方法主要包括两个部分：

1. 激励；即通过每个区块产生一定量的新比特币来激励参与者；
2. 引入外部资源确保安全；即通过大量的外部计算来确保共识的安全性，也就是工作量证明（Proof of Power）；

这也是几乎所有PoW币种所采用的的方法。

而这套方法要能持续长期运行下去的前提就是：

1. 这种激励对参与者要有足够的吸引力；也就是说比特币要一直涨价，才能吸引参与者持续参与挖矿计算，以维护整个网络的运行；否则就会导致参与的人减少，破坏网络安全；
2. 没有外部攻击；由于比特币引入了外部计算来确保安全，因此只要有足够的挖矿算力（超过维护系统算力的51%）就能对系统成功进行攻击，这也是比特币长期存在的安全隐患之一；因为只要有钱，就能买到设备和算力。

正是由于比特币存在的问题，例如消耗大量的资源、外部51%攻击等，出现了PoS（Proof of Stake）共识机理。

总体上，PoS共识理论和实践目前仍处在探索阶段。

最原始的PoS机理就是用股权代替PoW中的挖矿算力，来模拟比特币的挖矿过程。请注意，这个过程没有引入外部资源，而是仅仅依靠自身的币种股份来维护网络安全，因此其不需要消耗大量能源来进行计算；而且由于其没有引入外部的资源，因此不会担心外部攻击，例如外界的算力攻击。

看起来PoS是很完美的，但是它存在一个严重漏洞。

PoS存在内部的Nothing-at-Stake攻击。

什么是Nothing-at-Stake（常写作N@S）攻击？

假设系统中出现了两个分支链，那么对于持有币的”挖矿者“来讲，最佳的操作策略就是同时在两个分支上进行“挖矿”，这样，无论哪个分支胜出，对币种持有者来讲，都会获得本属于他的利益，即不会有利益损失。而且由于不需要算力消耗，因此PoS中在两个分支上挖矿是可行的。

这导致的问题是，只要系统存在分叉，“矿工们”都会同时在这几个分支上挖矿；因此在某个情况下，发起攻击的分叉链是极有可能成功的，因为所有人也都在这个分叉链上达成了共识；而且甚至不用持有51%的币量，就可以成功发起分叉攻击；

而这在PoW中是不可行的，因为挖矿需要消耗算力，矿工只能在一个分支上进行挖矿。

第二个问题是重写历史攻击；即攻击者可以通过购买原始持有币种的账户来从头发起攻击，重新分叉一个区块链。因为原始的币种持有者可以将币转移至其它账户，因此他是可以在没有损失的情况下将原始账户出售给攻击者的。攻击者需要的就是有足够数量币的原始账户；当然了，这也只是概率问题，因为有可能原始账户持有者不会出售他们的账户，但是理论上确实存在这种攻击。

第三个问题是，尽管PoS中的挖矿不用消耗算力，运行成本很低，但是也存在如何激励矿工的问题。因为一般的PoS系统是没有新币产生的，矿工只能赚取交易费，而且在交易费不高的情况下，对矿工的激励也是很有限的。

当然了，也有很多PoS币种解决这个问题的办法就是持续的再产生新币来激励挖矿者，这导致的问题就是通胀。

上述3个问题是PoS要解决的，尤其是N@S的问题尤为重要，因为如果没有其它约束机制，这种攻击是完全有可能实现的。

从以上可以看出，无论是PoW还是PoS机理的共识过程，其必要条件有两个：

1. 信息公开共享；
2. 个体参与；

以现实为例，事件的信息越透明、所涉及到的人员参与度越高，最终形成的共识也就越稳定、越持久。这与区块链共识是一致的。

【参考阅读】

• 分布式共识
• PoW vs PoS共识讨论
• PoS共识机理研究
• N@S攻击不可行性
• It will cost you nothing to kill a  Proof of Stake  crypto currency
• Bitcoin PoS
• Ethereum PoS
• Nxt PoS
• DPoS of BitShares

什么是智能合约

    智能合约是代码和数据的集合，寄存与Blockchain的具体的地址。智能合约更想是在Blockchain中的一个自动化的代理(或者说是机器人or NPC)，智能合约有自己的账户，在时间或事件的驱动下能自动执行一些功能，如可以在相互之间传递信息，修改区块链的状态(账户信息等)，以及图灵完备计算(可以用图灵机做到的所有事情，通俗来说就是一般编程语言可以做的所有事情)。以太坊的智能合约是以太坊特定的字节码，被叫做EVM字节码。

智能合约高级语言

    用户不可能直接编写EVM字节码，所以以太坊提供了几种编写智能合约的高级语言。

    Solidity：类JavaScript，这是以太坊推荐的旗舰语言，也是最流行的智能合约语言。具体用法参加Solidity文档。

    Serpent：类Python

    LLL：类Lisp

    可以根据不同的习惯选择不同的高级语言。这里选用最流行的Solidity

相关概念

    以下的概念是智能合约可能用到的，这里不做详细介绍，想了解的可以参考 智能合约菜鸟教程

    公钥加密系统：

    点对点网络：

    区块链：区块链可以看做是智能合约的基础设施

    以太坊虚拟机：解释执行智能合约字节码的东西，功能类似于Java虚拟机

    节点：

    矿工：区块链中参与处理区块的节点叫做矿工。当前以太坊活跃的矿工：https://ethstats.net/

    工作量证明：矿工们总是在竞争解决一些数学问题。第一个解出答案的(算出下一个区块)将获得以太币作为奖励。然后所有节点都更新自己的区块链。所有想要算出下一个区块的矿工都有与其他节点保持同步，并且维护同一个区块链的动力，因此整个网络总是能达成共识。

    以太币：ETH，以太坊中的虚拟货币，可以购买和使用，也可以与真实货币交易。以太币的走势图

    Gas：相当于手续费。在以太坊执行程序以保存数据都要消耗一定量的以太币。这个机制可以控制区块链中计算的数量，保证效率。

智能合约与DApp

    以太坊社区把基于智能合约的应用称为去中心化的应用程序(Decentralized App)。DApp的目标是(或者应该是)让你的智能合约有一个友好的界面，外加一些额外的东西，例如IPFS（可以存储和读取数据的去中心化网络，不是出自以太坊团队但有类似的精神)。DApp可以跑在一台能与以太坊节点交互的中心化服务器上，也可以跑在任意一个以太坊平等节点上。(花一分钟思考一下：与一般的网站不同，DApp不能跑在普通的服务器上。他们需要提交交易到区块链并且从区块链而不是中心化数据库读取重要数据。相对于典型的用户登录系统，用户有可能被表示成一个钱包地址而其它用户数据保存在本地。许多事情都会与目前的web应用有不同架构。)

    DApp流程：

1. 用Solidity(或其他语言)编写智能合约(后缀为.sol)
2. 用solc编译器将.sol合约编译成EVM字节码
3. 编译好的字节码回送给dapp前端
4. 前端将编译好的智能合约部署到区块链中
5. 区块链返回智能合约地址+ABI(合约接口的二进制表示。合约接口用JSON表示，包括变量，事件和可以调用的方法)
6. 前端通过Address+ABI+nonce，调用智能合约。智能合约开始处理。

智能合约编译器

    Solidity智能合约可以通过多种方式进行编译

• 通过在线Solidity实时编译器来编译。online Solidity realtime compiler
• 安装solc编译器编译
• 在客户端javascript console中，通过web3.eth.compile.solidity编译。不过这个需要环境中安装solc编译器。
• The Meteor dapp Cosmo for building solidity contracts
• The Mix IDE
• The Ethereum Wallet

    在这里选择solc和web3.eth.compile.solidity方式

geth安装

    参考：go Ethereum client。安装不比较简单，这里详细说了

solc安装

1. 作为cpp-ethereum的一部分安装  

    如果通过编译的方式安装了cpp-ethereum(参考：http://www.cnblogs.com/fengzhiwu/p/5547911.html)，那么solc编译器就会作为cpp-ethereum的一个子项目也被编译安装，在webthree-umbrella/build/solidity/solc目录下找到solc编译器的可执行文件。

    然后，在/bin或/usr/bin目录下创建软链接就行了

ln -s /home/vagrant/Code/workspace/webthree-umbrella/build/solidity/solc/solc /bin/solc

2. 单独安装solc

参考：http://solidity.readthedocs.io/en/latest/installing-solidity.html

• 通过npm安装：这种比较简单，运行npm install solc就行了，不过我没有在console中找到solc
• 通过apt-get安装：

sudo add-apt-repository ppa:ethereum/ethereum

sudo apt-get update

sudo apt-get install solc

which solc

    把solc添加入geth中直接使用（在geth中输入）

admin.setSolc("path/to/solc")

• 从源码编译安装

    这种方法和安装cpp-etheruemle类似，不过最后的编译步骤改为：

cd webthree-umbrella

./webthree-helpers/scripts/ethupdate.sh --no-push --simple-pull --project solidity # update Solidity repo ./webthree-helpers/scripts/ethbuild.sh --no-git --project solidity --cores 4 -DEVMJIT=0 -DETHASHCL=0 # build Solidity only

测试

    打开一个geth console，输入：web3.eth.getCompilers()，就会打印

智能合约体验

编译一个简单的合约

    直接在console中编译一个简单的合约代码

> source = "contract test { function multiply(uint a) returns(uint d) { return a * 7; } }"

> clientContract = eth.compile.solidity(source).test

编译返回的结果的JSON格式如下

其中，

code：编译后的EVM字节码

info：编译器返回的metadata

abiDefination:Application Binary Interface定义。具体接口规则参见这里

compilerVersion：编译此代码的solidity编译器版本

developerDoc：针对开发者的Natural Specification Format，类似于Doxygen。具体规则参见这里

language：合约语言

languageVersion：合约语言版本

source：源代码

userDoc：针对用户的Ethereum的Natural Specification Format，类似于Doxygen。

编译器返回的JSON结构反映了合约部署的两种不同的路径。info信息真实的存在于区中心化的云中，作为metadata信息来公开验证Blockchain中合约代码的实现。而code信息通过创建交易的方式部署到区块链中。

创建和部署合约

在进行此步骤前，确保你有一个解锁的账户并且账户中有余额。（可以创建自己独立的测试网络，即自己的区块链，初始化的时候就可以初始化一些有余额的账户）。参考：Test Networks

现在就可以在区块链中创建一个合约了。创建合约的方式是发送一个交易，交易的目的地址是空地址，数据是前面JSON结构中的code字段。

创建合约的流程如下

var primaryAddress = eth.accounts[0] var abi = [{ constant: false, inputs: [{ name: 'a', type: 'uint256' } ]}] var MyContract = eth.contract(abi) var contract = MyContract.new(arg1, arg2, ..., {from: primaryAddress, data: evmByteCodeFromPreviousSection}) //arg1,arg2,...是构造参数，这里没有，需要去掉。红色部分用前面生成的code代替

i. 获得账户

ii. 定义一个abi （abi是个js的数组，否则不成功）

iii. 创建智能合约

iv. 发送交易部署合约

如果交易被pending，如图说明你的miner没有在挖矿，

启动一个矿工

miner.setEtherbase(eth.primaryAddress)    //设定开采账户

miner.start(8)

eth.getBlock("pending", true).transactions

这时候发现交易已经在区块中

不过会发现，交易还是pending，这是因为该交易区块没有人协助进行运算验证，这时候只需要再启动一个矿工就行了

miner.start(8)

参考：Private Testnet

发现区块1部署了交易

与合约进行交互

可以通过eth.contract()定义一个合约对象，这个对象包含变数合约接口的abi

Multiply7 = eth.contract(clientContract.info.abiDefinition); var myMultiply7 = Multiply7.at(contract.address);

到这儿，就可以调用智能合约的函数了。

myMultiply7.multiply.call(3)

或

myMultiply7.multiply.sendTransaction(3, {from: contract.address})

结束

    到此，对智能合约的初次体验就结束了。另外智能合约以及DApp还可以干很多NB的事情。以后会进一步讨论。