发表于 | 分类于 | 评论数：

程序员为什么写公众号？

就个人来说，程序员写公众号，最重要的是什么？

不是粉丝，不是出名，不是收益（不在意是假的），而是学习、总结、创作、分享（至少可以实践费曼学习技巧）。

定好初心，然后出发，坚持（出发难，坚持更不简单），剩下会得到什么则交给上帝决定。

这里每个人的答案各不一样，什么样的初心，就会写出什么样的文章。

写作是个什么样的体验？

关键词一：不简单

看别人写的文章似乎觉得很容易，那是看起来容易……

写作有两种：一种是抄，一种是原创。

抄呢看着不难，实际操作起来估计也不简单，要高质量的抄，一得选对好文章，二也得调整润色等等让人看不出来是抄的；而要大批量的抄，至少得会写个爬虫吧。

目前为止，自己发过的文章都是坚持原创：自己选好题，自己构思结构，自己写内容，自己写例子。原创有多难呢，有时一篇文章写个一周都觉得写不好，写写改改，一个最简单的文章估计至少也得一两个小时，也许是不熟练的缘故，真是很佩服那些天天都能发文的人。

关键词二：进步

写文章带来的好处：为了能更好的输出，自然就需要更多的输入，输入的素材可以是自己觉得未吃透的某个专题深入，也可以是自己感兴趣想学习的最新技术，另外写作过程其实就是实践费曼学习技巧的过程，因此对技术和知识可以有更深刻的理解，这样的过程自然而然就给自己带来了进步，过程中可能没感觉，但一段时间后就会感觉到。

关键词三：满足感

除了自我不断进步的内部正向反馈，还有就是假如写了一篇自己感觉不错的文章，也受到别人的认可，那么这其中带来的满足感是很充盈的，进而促使自己坚持下去，然后写更好的文章，这可以算是外部的正向反馈。

除了公众号，还可以发哪些平台？

文章除了公众号，还可以发到更多的平台，增加曝光度，目前同步发布的有：

  • 自己的博客
  • 公众号
  • 今日头条
  • CSDN
  • 简书

还有很多别的平台，不过一开始的时候可以先选好一两个目标平台，等整个发文过程熟悉熟练后，再添加更多别的平台同步发布。

用哪些工具来写作？

多平台写作必须得用Markdown，一次写作，同时发布到多个平台。这其中个人用的Markdown编辑器是Typora，功能全，兼容性好，所见即所得，不需要非常精通Markdown语法，可以傻瓜式可视化编辑排版，也可以进入专业模式直接撸Markdown语法。

目前很多平台是支持Markdown发文的，Markdown的文章写好了可以直接发布，对于公众号、头条号等不支持Markdown的，可以用http://md.aclickall.com/在线一键排版了，然后拷贝到公众号、头条号里。

另外对于公众号还可以使用微小宝这个软件做辅助编辑，里面包含各种模版，可以拿来用用，不过呢一开始时用得挺欢，后面就返璞归真，就只是文章了，估计是懒或用得不熟练的缘故。

发表于 | 分类于 | 评论数：

回顾

先回顾下面向对象的三个基本特性：

  • 封装
  • 继承
  • 多态

Java作为面向对象的王者，以下示例完美的展现了面向对象的三个基本特征。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Main {
    public static void main(String[] args) {
        List<Payroll> all = new ArrayList<>();

        //员工类封装了数据（姓名、年龄、性别）和行为（计算薪酬）
        //销售员工和技术员工继承自员工类，都实现了计算薪酬的接口
        //机器不是员工，但实现了计算薪酬的接口，也可以计算薪酬
        all.add(new SaleEmployee());
        all.add(new TechEmployee());
        all.add(new Machine());

        //多态：不管是人还是机器，只要实现了Payroll接口，就都可以正确的计算出各自的薪酬
        for (Payroll payroll : all) {
            System.out.println(payroll.calcSalary());
        }
    }
}

那么Go语言呢？我们一起来探索下Go语言的面向对象，先从类的封装开始。

封装

员工薪酬示例中，Java里的Employee类是这样的：

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
public abstract class Employee implements Payroll {
    private String name;
    private String sex;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

这里暂时先关注员工类的三个属性，Go里面它确实没有类，要表示上面的员工对象，它是用struct的（和C很像）：

1
2
3
4
5
type Employee struct {
	Name string
	Sex string
	Age int
}

看起来简洁多了，注意到Go里面没有private public的修饰符，它是用属性的首个字母大小写来区分private public，小写字母开头的是私有属性，大写字母开头表示公开属性。对象的实例化和使用对比：

1
2
3
4
//由于Employee是抽象类，不能实例化，直接用子类TechEmployee实例化
Employee tech = new TechEmployee();
tech.setName("lee");
System.out.println(tech.getName());
1
2
3
4
5
6
7
8
//这里的object.是包名，Employee放在object目录下
tech := object.Employee{
    Name: "lee",
    Sex:  "male",
    Age:  20,
}
tech.Name = "bruce lee"
fmt.Println(tech.Name)

另外，struct中是没有方法（行为）的，少了这个不是等于封装特征缺了只脚吗？当然不是了，Go语言里对应面向对象里的成员方法不是定义在struct里面，而是直接定义在struct外面，和struct平级，这里定义一个类似Java中的toString方法：

1
2
3
4
5
6
7
8
9
type Employee struct {
	Name string
	Sex  string
	Age  int
}

func (e *Employee) ToString() string {
	return "name=" + e.Name + ";sex=" + e.Sex + ";age=" + strconv.Itoa(e.Age)
}

这里(e *Employee)叫做方法的接收者，有点怪异，我们可以这样理解：

  1. Go里没有this，要自己加个类似this的东西，用于指代方法对应的实例，括号里前面的e相当于this，当然名字可以随便取。
  2. 方法定义和struct平级，如果不加个接收者定义，哪里知道这个方法属于谁的呢，括号里后面的类型表示这个方法属性于谁的，这里可以用（e Employee）或（e *Employee），区别是传值还是传指针，一般统一用后者。

继承

接下来继承，先看看Java的：

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
public class TechEmployee extends Employee {
    private double salaryPerMonth;

    public double getSalaryPerMonth() {
        return salaryPerMonth;
    }

    public void setSalaryPerMonth(double salaryPerMonth) {
        this.salaryPerMonth = salaryPerMonth;
    }

    @Override
    public double calcSalary() {
        return salaryPerMonth;
    }
}

public class SaleEmployee extends Employee {
    private Double baseSalary;
    private Double extraRate;

    public Double getBaseSalary() {
        return baseSalary;
    }

    public void setBaseSalary(Double baseSalary) {
        this.baseSalary = baseSalary;
    }

    public Double getExtraRate() {
        return extraRate;
    }

    public void setExtraRate(Double extraRate) {
        this.extraRate = extraRate;
    }

    @Override
    public double calcSalary() {
        return baseSalary * (1 + extraRate);
    }
}

同样，Go里面也没有像Java中类似extend继承的语法，Go是用了类似Java里组合的东西来让语法看起来像继承：

1
2
3
4
5
6
7
8
9
10
type TechEmployee struct {
	Employee
	SalaryPerMonth float32
}

type SaleEmployee struct {
	Employee
	BaseSalary float32
	ExtraRate  float32
}

对应的实例化和使用：

1
2
3
4
5
6
7
8
//实例化时，是传了个employee
tech := object.TechEmployee{
    Employee:       object.Employee{Name: "lee"},
    SalaryPerMonth: 10000,
}
//这里看起来像拥有了Employee的name属性，可以设置和访问
tech.Name = "bruce lee"
fmt.Println(tech.Name)

多态

关于多态，必须要提接口，终于Go里也是有接口的了：

1
2
3
public interface Payroll {
    double calcSalary();
}
1
2
3
type Payroll interface {
	CalcSalary() float32
}

接口的实现：

1
2
3
4
5
6
public class Machine implements Payroll {
    @Override
    public double calcSalary() {
        return 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
type TechEmployee struct {
	Employee
	SalaryPerMonth float32
}

func (e *TechEmployee) CalcSalary() float32 {
	return e.SalaryPerMonth
}

type Machine struct {

}

func (e *Machine) CalcSalary() float32 {
	return 0
}

可以看出，Java里比较直观，语法里直接写着实现xxx接口，Go相比的话，没那么直观，但更灵活，它没有指定实现哪个接口，而是如果定义了一个相同名字和返回值的方法，就认为是实现了对应拥有这个方法的接口，这里假如接口有两个方法，对应也必须要两个方法都有定义了，才认为是实现了接口。

最后，看一下集成使用的对比：

1
2
3
4
5
6
7
8
9
10
11
12
13
List<Payroll> all = new ArrayList<>();

//员工类封装了数据（姓名、年龄、性别）和行为（计算薪酬）
//销售员工和技术员工继承自员工类，都实现了计算薪酬的接口
//机器不是员工，但实现了计算薪酬的接口，也可以计算薪酬
all.add(new SaleEmployee());
all.add(new TechEmployee());
all.add(new Machine());

//多态：不管是人还是机器，只要实现了Payroll接口，就都可以正确的计算出各自的薪酬
for (Payroll payroll : all) {
    System.out.println(payroll.calcSalary());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var all [3] object.Payroll

all[0] = &object.TechEmployee{
    Employee:       object.Employee{Name: "lee"},
    SalaryPerMonth: 10000,
}
all[1] = &object.SaleEmployee{
    Employee:   object.Employee{Name: "lee"},
    BaseSalary: 10000,
    ExtraRate:  0.1,
}
all[2] = &object.Machine{}

for _, item := range all {
    fmt.Println(item.CalcSalary())
}

发表于 | 分类于 | 评论数：

Map

声明和初始化
方式一
1
rec := map[string]int{"width": 1, "height": 3}
方式二
1
2
3
rec1 := make(map[string]int)
rec1["width"] = 1
rec1["height"] = 3

以上两种声明和初始化方式效果是一样的，根据实际情况选用。试试访问不存在的Key看会怎样？

1
fmt.Println(rec["point"])

结果会输出：0，不会报错！它返回了int的默认值：0。

Key是否存在

那怎么判断一个Key到底是否存在呢？可如下实现：

1
2
3
4
5
if val, ok := rec["point"]; ok {
    fmt.Println(val)
} else {
    fmt.Println("key point not exists")
}
遍历
1
2
3
for k, v := range rec {
    fmt.Println(k, "=", v)
}
删除Key
1
2
3
4
5
6
delete(rec, "width")
if val, ok := rec["width"]; ok {
    fmt.Println(val)
} else {
    fmt.Println("key width has been deleted")
}

指针

Go作者之一是Thompson，他发明了后来衍生出C语言的B程序语言，作为鼻祖，设计的新语言指针必须有。Go里的指针和C的指针语法使用上基本一样，区别是Go里不能对指针进行算术运算。

1
2
3
4
5
6
7
8
9
10
11
12
13
func pointers() {
	x := new(int)
	*x = 2
	fmt.Println(reflect.TypeOf(x), *x, x)

	y := 2
	fmt.Println(&y, reflect.TypeOf(&y), reflect.TypeOf(y))
	pointParam(&y)
}

func pointerParam(p *int) {
	fmt.Println(reflect.TypeOf(p), p, *p)
}

上面的new可以看成是C里面的malloc，为类型分配对应的内存空间，然后返回对应内存的指针即内存地址，new函数相当于下面的函数功效：

1
2
3
4
5
func newInt() *int {
  var i int
  return &i
}
x := newInt()

发表于 | 分类于 | 评论数：

第一种声明方式

1
2
3
4
var firstArray [2] int
fmt.Println(firstArray[0])
firstArray[1] = 1
fmt.Println(firstArray[1])

这是第一种数组声明方式，未初始化的元素值默认为0，需要指明数组的长度，然后使用下标索引方式初始化和访问元素。

简洁的方式

我们知道Java中数组还有这种初始化方式，直接初始化具体元素，数组长度自动获得：

1
int[] intArray = new int[]{1, 2, 3, 4, 5};

对应在Go中是这样的：

1
2
3
4
5
6
7
8
9
secondArray := [...]int{1, 2, 3, 4, 5}

//数组的循环
for index, item := range secondArray {
    fmt.Println(index, item)
}
for i := 0; i < len(secondArray); i++ {
    fmt.Println(i, secondArray[i])
}

有点怪异，不习惯，第一次使用还有可能会把[…]中的…省略了，如果省略了，那就不是一个数组了，而是一个slice，可以用下面的代码验证一下：

1
2
fmt.Println(reflect.TypeOf([]int{1, 2}))
fmt.Println(reflect.TypeOf([...]int{1, 2}))

输出结果是：[]int和[2]int。看着又是很相似的结果，但[]int是slice，[2]int是数组，中括号中有数字表示是数组。

SLICE

说到slice，slice是什么？先看下slice怎么得到：

1
2
sliceOfArray = secondArray[0:1]
fmt.Println(reflect.TypeOf(sliceOfArray)

上面的输出结果也是[]int，和上一段代码：fmt.Println(reflect.TypeOf([]int{1, 2}))输出是一样的。这个slice和Python里的列表slice很像（Java数组没有slice功能，只能用apache-commons中的ArrayUtils实现类似功能）：

1
2
3
4
5
6
7
int_list = [1, 2, 3, 4, 5]
sub_list = int_list[0:1]

#python的slice更灵活
print(int_list[0:])
print(int_list[:3])
print(int_list[0:-1])

从表面使用上看的话，就是取子数组或子列表的功能，但更深入看，Python中的列表slice操作返回的是一个新的子列表，而Go中slice操作返回的不是一个新的子数组，而是一个和原数组共用内存的slice，这样的设计可以减少切片操作时的内存消耗，提高性能，这里我们可以把生成的slice看做的原数组的一个子片断视图，它本身不存数据，访问到的元素，还是原数组里的元素。

发表于 | 分类于 | 评论数：

初始化

1
2
3
4
5
6
msg := "hello world"
cnMsg := "你好世界"
multiline := `
				select * from table
				where col='val'
			`

单行的字符串初始化和大部分语言一样，使用双引号，支持和python一样的多行，但是用反单引号，就是键盘上按键区最左上角的那个符号。

长度

1
2
3
4
msg := "hello world"
fmt.Println(len(msg))
cnMsg := "你好世界"
fmt.Println(len(cnMsg))

上面两个打印字符串长度的代码会输出多少？11和4吗？错了，答案是11和16，len方法取得的结果是字符串所占用的字节数，go语言中的字符串使用的是可变长的UTF8编码，ASCII码占用1个字节，其它字符是2-4个字节，对于中文字符是3个字节。那如何取得我们预想的字符串长度：11和4？可以使用如下的两个方法：

1
2
fmt.Println(utf8.RuneCountInString(msg))
fmt.Println(utf8.RuneCountInString(cnMsg))

这里的rune可以认为用于表示一个utf8编码，如果想把汉字字符串，一个个打印出来，可用如下方法实现：

1
2
3
4
5
cnMsg := "你好世界"
msgRunes := []rune(cnMsg)
for _, c := range msgRunes {
    fmt.Println(string(c))
}

SLICE

1
2
3
4
5
msg := "hello world"
fmt.Println(msg[:5])
fmt.Println(msg[6:])
fmt.Println(msg[3:5])
fmt.Println(msg[0])

对于ASCII码字符串可以使用上面的方法进行类似Java substring的操作，注意最后一个返回的是h的ASCII码值。对于中文字符如果也像上面的方式操作，打印出来的结果会是乱码，因为上面的操作是基于字节索引的，中文的substring要像下面这样操作，先转成rune表示的UTF8编码数组，然后基于UTF8编码索引：

1
2
cnMsg := "你好世界"
fmt.Println(string([]rune(cnMsg)[0:1]))

发表于 | 分类于 | 评论数：

IDE

关于IDE，开发时推荐JetBrains的GoLand，JetBrains系列IDE的好无需多言了，不过建议第一次跑hello world时，还是用简单的文本编辑器（sublime text/vs code/atom等）和go的命令，手动操作后加深理解。

GOPATH

安装完后go后，默认的GOPATH可以通过下面的命令获得：

1
go env GOPATH

如果只输go env的话会把go的所有相关环境变量打印出来。

默认的GOPATH一般都在用户目录下，一般要设置修改成自己的工作目录：

windows在系统属性中添加环境变量GOPATH=D:\workspace。

linux

1
export GOPATH=$HOME/workspace

设置上述GOPATH环境变量的同时，可以把%GOPATH%\bin（windows）或$GOPATH/bin（linux）追加到path环境变量中，方便生成的go程序使用命令行调用时，可以在任意目录执行。

workspace

上一步设置好的GOPATH就是go的workspace了，go的workspace目录结构通常是这样的：

workspace

​ -src

​ -pkg

​ -bin

pkg

可以把pkg认为像java里的放jar包的目录一样，是生成的库文件。

bin

bin目录放生成的可执行文件。

src

关键看src，src的目录结构一般如下：

src目录下面第一层是代码版本管理库的服务器名称，像如图所示的github.com，也可以是gitee.com，或者是xx.com，只是表示代码版本管理库的服务器名称，可以是git，也可以是svn。

再下一层，对于github来说，一般是对应用户，如图github.com下面有两个用户一个是ethereum，一个是golang，然后再下一层就是具体的项目，这里不是必须这样，如果svn就可以直接是具体的项目名了。

当到了项目一层目录时，再里面的子目录和文件，就和别的语言里差不多了，具体项目的工程文件在这个目录里。

用JetBrains GoLang打开golang的example项目时，长这样：

发表于 | 分类于 | 评论数：

学习的理由

  1. 简单
  2. 编译快
  3. 部署，运行简单
  4. 高性能，高效率，适合并发
  5. 很多区块链开源项目使用go语言开发
  6. 学习应该是码农的本能

Hello World

1
2
3
4
5
6
7
package main

import "fmt"

func main() {
	fmt.Printf("hello world")
}

hello world的代码看上去还好，比java简洁，和python一样语句不用分号来结束。

变量

1
var i int = 0

上面是一个最完整的变量声明语句，这个看着就稍微有点奇怪了，有点像javascript，后面又多了个类型声明，习惯了java里类型声明在前面，或者像javascript，python一样没有类型声明。

不过就如刚才所说，上面是一个最完整的变量声明语句，实际还可以这样声明使用：

1
2
var i = 0
var msg = "hello, world"

嗯，这还差不多，很javascript了。变量的类型由变量的初始化值决定。

还可以更简单吗？

1
2
i := 0
msg := "hello, world"

啧啧，nice！不过注意，这种写法是声明变量的同时进行初始化，当已经写过一个i := 0时，后面就不能再来个i := 1了，因为这样表示声明了两个变量，名字都为i，:=在这里是声明变量且赋值初始化。

再来个惊叹的：

1
2
x, y := 1, 2
x, y = y, x

上面的两个语句做了什么？第一行是声明并初始化了两个整型变量x和y，第二行把x和y的值对调！对调两个变量的值竟然可以这么简单！对比下java的版本：

1
2
3
4
5
int x = 1;
int y = 2;
int tmp = x;
x = y;
y = tmp;

条件分支

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
i := 10
if i < 1 {
    fmt.Println("i < 1")
} else if i >= 1 && i < 5 {
    fmt.Println("i >= 1 && i < 5")
} else {
    fmt.Println("i >= 5")
}

lang := "go"
switch lang {
    case "go":
    	fmt.Println("go is best")
    case "java":
    	fmt.Println("java is best")
    case "python":
    	fmt.Println("python is best")
    default:
    	fmt.Println("go is best")
}

条件分支看起来就差不多了，和java相比省略了括号，别的差不多。

循环

for
1
2
3
for i := 0; i < 5; i++ {
	fmt.Println("go语言的for循环长这样")
}

for循环看起来也差不多，和java相比，少了括号。

range
1
2
3
4
5
6
7
8
9
10
11
12
13
word := []string{"h", "e", "l", "l", "o"}
for index, char := range word {
    fmt.Println(index, char)
}
for _, c := range word {
    fmt.Println(c)
}
for i, _ := range word {
    fmt.Println(i)
}
for i := range word {
    fmt.Println(i)
}

关于range，可以用来遍历数组，列表，键值对，这里仅以数组为例说明。

当对数组使用range时，会返回两个变量，第一个变量是数组的索引，第二个变量是数组对应索引的值。

这和java里的for … in …有点像，但这个支持取索引，和javascript中的each也挺像。

上面第二个for写法第一个变量是一个下划线，表示对index不感兴趣，这里就用下划线来占位。

类似，第三个for对value不感兴趣，就把value用下划线来占位。

第四个for其实效果和第三个for一样，如果只写一个变量，默认是index。

while
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
for {
    fmt.Println("go语言很奇葩，没有while")
}

i := 1
for i <= 5 {
    fmt.Printf("%d:go语言很奇葩，没有while\n", i)
    i++
}

i = 1
for true {
    if i > 5 && 1 > 0 {
        break
    }
    fmt.Printf("%d:go语言很奇葩，没有while\n", i)
    i++
}

go语言很奇葩，竟然没有while，上面的三个for分别对应java里的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
while (true) {
    //xxx;
}

while (i <= 5) {
    //xxx;
}

while (true) {
    if (i > 5 && 1 > 0) {
        break;
    }
    //xxx;
}
结语

go语言的初体验先到此为止，语法上确实有它简单的地方，也有它奇葩的地方，看看，写写，跑跑，go语言之路走起。

发表于 | 分类于 | 评论数：

引言

最初接触区块链相关时，看了很多文章，真的是云里雾里，不知所云，区块链到底是什么？能干什么？看半天还是没明白，相信很多人都有类似的感觉。

区块链是什么？

区块+链

对数据结构有印象的同学，应该脑子里会浮现出现链表，是的，它们俩很像。

所以从这个角度讲，区块链本身这个词就描述了它的数据结构属性，它是拿来存数据的。

具体来讲，一个区块，包含区块头和区块体，区块头包含了时间戳和上一个区块的哈希等信息，区块体则是一个交易列表，整个区块进行哈希计算后生成自己的哈希，后面的区块按同样的方式包含了上一个区块的哈希，这样就把所有区块串起来变成一条链。

由于每个区块都包含了前一个区块的哈希，如果想要篡改第3个区块，那么第3个区块后面的区块也要全部重新计算哈希全部篡改过去，这样的结构保证了区块链数据很难被篡改。

账本

那区块链一般拿来存什么的？最常见的应用就是账本，我们可以很容易的把区块链的结构和账本类比对应起来，一个区块相当于账本里的一页，一页的账目流水相当于区块中的交易列表，我们按时间顺序记账，唯一区别是，区块链可以无限增长，账本是有限的，用完就得换一本。所以区块链也常常被称为超级账本，有些开源项目的名称就会含有ledger这个词。

去中心化

如果区块链只是一种数据结构，那么它就不会被那么多人追捧了。上面提到区块链数据很难被篡改，那只是很难，如果区块链数据是中心化存储的，那只要对这个中心化存储有控制权的人完全可以任意修改，区块链的创新之处在于，它有很多去中心化的节点，每个节点上都有一条自己的链，不同节点通过同步，保证和网络上别的节点上的链处于一致状态，那些链状态不正确的节点会被其它节点剔出网络，这样某些恶意个人或组织，想篡改数据就得控制网络上大量的节点，这是非常非常困难，几乎不可能的。

共识

聪明的同学可能会问，这么多节点，每个节点上都有链，那谁来记账，也就是谁来生成新的区块呢？以谁的为准呢？这就引出了共识机制，以比特币为例，每个节点都可以参与记账，但比特币网络使用了叫POW工作量证明的共识机制，通俗讲就是出一道有难度的数学计算题，第一个计算出来的节点获得记账权，然后这个节点把内存里的交易按时间排序打包到区块追加到自己的链上，同时广播出去，别的节点这时只需同步即可，这个过程，比特币也叫做挖矿。

智能合约

除了最常见的记账应用，如果要应用在别的领域，能实现吗？要修改底层实现吗？不需要，区块链2.0引入了智能合约，智能合约就是拿来在区块链上扩展实现各种不同的应用，可以把智能合约当作区块链上的二次开发语言，它可以定义业务对象的属性，状态，以及不同个体或组织对业务对象可以做哪些操作（即区块中的交易），通过智能合约把业务合约化，自动化。

RSA

聪明的同学又问了，这链上的资产类业务对象，任何人都可以操作吗？归属于谁的？继续以比特币为例，张三拥有100个比特币，这100个比特币怎么确认是张三的，怎么保证只能由张三花掉？这里用到了RSA的公钥和私钥，100个比特币在数据层面是一个input，input里包含了张三的公钥信息，100的数量，还有用张三公钥生成的一个锁定脚本，这个锁定脚本只能用张三的私钥去解锁，这样就保证了资产的归属和使用权。

总结

总结一下，区块链的主要特征：

  1. 分布式的时间序列数据存储（轻对象）
  2. 不可篡改
  3. 去中心化
  4. 开放
  5. 安全
  6. 可扩展

因此区块链也被称为下一代互联网：可信的价值互联网。

区块链能干什么？

我们想象一下，现实世界中的各种资产对象，放到链上存储和跟踪，然后不同的个人和组织可以方便的在一个公共的可信网络和存储里按照共同认可的规则互相协作，不同的企业，机构，组织之间的壁垒被打破，业务运作流转更自动化，更高效，更可信。再想想我们当前的状态：这个企业自个儿弄个系统，另外一个机构又弄一个系统，各自有各自的数据，谁也不知道对方数据到底有没有被改过，再来系统对接，联调，甚至跨国机构、组织，想想就觉得费劲。

学习资料

书籍
  • 精通比特币
  • 区块链技术及应用
开源项目
  • bitcoinj
  • ethereum
  • hyper ledger fabirc

发表于 | 分类于 | 评论数：

背景

生产环境的有些sql查询写得太复杂，或是表很大，对应索引未建立或建立不合理，或是查询未充分使用索引等，就有可能出现慢查询，一些慢查询需要修改程序，可能没那么快能解决，这时如果有个脚本能自动检测符合条件的慢查询会话并结束，那么是很方便的，当然运维人员也可顺便弄个检测慢查询并告警的脚本。

涉及知识点

  1. mysql慢查询会话查询
  2. schedule定时任务调度
  3. pymysql执行sql
阅读全文 »
0%