学好一门编程语言是十分不容易的,但是如果学会了,它的实用性是很强的,下面我为大家整理了学好一门编程语言的办法,大家可以参考借鉴。
一、多总结
多总结才能加深理解、增强记忆。举例,Go 中有 slice、map、channal 类型,它们都可以用 make 生成实例,但 slice 和 map 还可以用以下形式初始化,也是编程规范中建议的初始化方式:
colors := map[string]string{}
slice := []int{}
但注意了,channal 则没有这样的语法:msg := chan string{}
上面两句是生成实例,表示空集合,但下面两句则表示实例不存在,值为 nil
var colors map[string]string
var slice []int
另外,结构体指针 slice 还可以象下面这样初始化,结构体实例不用明确地指定类型(使用了类型推导)、不用明确地取地址运算(&)。
type Product struct {
name string
price float64
}
products := []Product{{"Spanner", 399}, {"Wrench", 249}, {"Screwdriver", 199}}
看到没有,如果不经常总结,这一圈学下来会把你整的稀里糊涂的。
二、多比较
学一门新语言一定要与你之前已经熟悉的语言经常作比较,找出它们的相同与不同,这样才能加深记忆和理解,否则学完之后脑子里会一片混乱,搞不清谁是谁非了。
就拿数组来说吧,在 Java、Scala、Go 中定义、实例化、赋值是不一样的。
//Java
int[] arr;//定义数组,不可以指定数组长度
arr = new int[5];//创建数组对象(实例化),指定数组长度
arr[1] = 8;//赋值
//Scala
val arr = new Array[Int](5) //数组在Scala里用的是泛型类,构造函数参数指定数组大小
arr(1) = 8 //赋值,注意用的是括弧
//Go
arr := [5]int{} //创建数组,初始化5个元素都为0,注意如果不指定数组长度,则是另外一种类型Slice
arr[1] = 8 //赋值
再比如 Map 在 Scala 与 Go 语言里定义、初始化、访问也是不同的,作了以下比较后印象会非常深刻,把它们记下来,这样以后使用就不会搞混了。
//Scala
val capital = Map("France" -> "Paris", "Japan" -> "Tokyo")
println(capitalget("France"))
//Go
capital := map[string]string{"France": "Paris", "Japan": "Tokyo"}
fmtPrintln(capital["France"])
Go 同时给多个变量赋值在 Scala 里可以用模式匹配做到,如下:
//Scala(使用样本类的模式匹配)
case class Tao(name: String, age: Int);
val Tao(myName, myAge) = Tao("taozs", 18);
println(myName)
println(myAge)
//Go
myName, myAge := "taozs", 18
fmtPrintln(myName)
fmtPrintln(myAge)
//Scala(使用元组的模式匹配)
val (myNumber, myString) = (123, "abe")
println(myNumber)
println(myString)
//Go
myNumber, myString := 123, "abe"
fmtPrintln(myNumber)
fmtPrintln(myString)
以下是 Scala 和 Go 定义和实现函数的区别:
//Scala
val increase: Int => Int = (x: Int) => x + 1
println(increase(8))
//Go
var increase func(int) int = func(x int) int { return x + 1 }
fmtPrintln(increase(8))
除了在 Scala 和 Go 里都可以类型推导外,在 Scala 里还可以这样定义函数:
//Scala
val increase = (_: Int) + 1
为方便自己将来随时查阅,可以建立下面这样的对比表格,描述不一定要求规范,自己能看懂就行。
三、转变思维方式,
学会用这门语言去思考
学会用语言去思考是关键。如果你以前是学 C 的,转学 Java,你一定要改变以前面向过程的思维,学会用面向对象的思维去分析问题;以前学 Java 的,转学 Scala 则要学会用函数式的编程思维解决问题。
举一个函数式编程的例子,以下是 Java 语言常用的 for 循环,循环变量从 1 到 10 执行 10 次循环体:
// 命令式编程
for (int i = 1; i < 10; i++) {
// 此处是循环体做10次
}
这被称为命令式编程 (Imperative Programming),但学了 Scala 的函数式编程 (Functional Programming) 后,解决同样的问题,我们可以换一种思维:构建 1 到 10 的列表序列,针对列表中的`每个元素分别执行函数,如下:
//函数式编程
val autoList = (1 to 10)map(i => /此处是函数体,针对1到10的每一个分别调用 1次/)
已经习惯了 Java 编程的,对 Scala 的函数式编程、样本类、模式匹配、不可变对象、隐式转换等需要一个逐步适应的过程,要渐渐学会用它们思考和解决问题。
再举个 Scala 与 Go 思维方式不同的例子,要实现对一个字符串里的每个字符加 1 的 *** 作,Scala 里可以这样:
"abc"map(cc => cc + 1)
"abc"是一个字符串对象,调用它的方法 map,这是纯面向对象的思维,但在 Go 里就要转变为面向过程的思维:
name := "abc"
second := stringsMap(func(x rune) rune {
return x + 1
}, name)
注意,这里的 strings 是包 (package),调用它的公共函数 Map,被人 *** 作的对象 name 字符串作为函数参数传入。Go 提供的函数 len、cap、append、 等其实都是面向过程的,虽然 Go 也提供有面向对象的支持,已经习惯了面向对象编程的,刚开始学 Go 语言需要特别留意这一点。
四、多看开源代码
学一门语言就是学一种思维方式,如今 GitHub 上可下载的开源代码海量级,通过看别人的代码,学习别人是如何解决问题的,养成用该语言思考的习惯,另外还能学习到一些非常有用的技巧,比如我在看一个 Go 语言性能测试框架代码时看到有以下写法:
func main() {
defer profileStart()Stop()
}
这个意思是指刚进入程序时执行 Start( ) 函数,程序退出前调用 Stop( ) 函数,非常好的技巧啊!可以用于需要在程序执行前和程序完成后分别执行一段逻辑的场景。再看 Start( ) 函数是怎么实现的:
func Start(options func(Profile)) interface {
Stop()
} {
return &prof
}
该函数返回了一个实现了含有 Stop( ) 函数接口的对象,如此才能在调用 Start 调用后连调 Stop。
五、优先学会使用代码分析工具
代码分析的工具包括静态检查、测试、测试覆盖率分析、性能分析(内存、CPU)、调试工具等,工具的价值在于它可以有效帮我们发现代码问题,这在我们刚开始学一门编程语言时意义尤其重大。
例如,以下这句 Java 赋值语句估计没有哪本教科书会告诉你有性能问题:
String sb = new String(“Hello World”);
以下这段 Java 代码你也不一定能意识到有多线程问题:
synchronized public void send(authuserPacket pkt, Thread t, String flowNo) throws IOException
{
loggerinfo("start");
//连接不可用,直接抛出异常,等待接收线程连接服务器成功
if (!thisavaliable)
{
try
{
//如果连接不可用,则等待2S,然后重新检测
Threadsleep(2000);
}
如果我们及时用 FindBugs 工具检查就会发现上面这些问题,进而你会去分析研究为什么,如此,你对这门语言的了解也会越来越多。
另外,Go 语言自带的 vet/test/cover/pprof/trace 都是非常有用的工具,一边学一边使用这些工具分析代码,能加深对语言的理解。
六、多练习、多实践
就象学自然语言一样,如果只知道语法不去练是没有任何效果的,只有反复地练习,慢慢才能变成自己的一项技能。书本上的例子代码最好能从头到尾亲自敲一遍,多运行、多尝试,另外再找一些题目来练习,如能有机会参与项目开发则更好啦,勤动手、勤实践是最好的学习方法。
其它的方法还有:
做好笔记,把学习中遇到的关键点和自己的思考记下来,便于后面复习和对比;
复习,学习一定要重复、重复、再重复;
学习贵在坚持,每天学一点(比如坚持每天学 1 小时),日积月累。
Go有四大核心模块,基本全部体现在runtime,有调度系统、GC、goroutine、channel,那么深入理解其中的精髓可以帮助我们理解Go这一门语言!
参考: 调度系统设计精要
下面是我用Go语言简单写的一个调度器,大家可以看看设计思路,以及存在的问题!
1、测试条件,调度器只启动两个线程,然后一个线程主要是负责循环的添加任务,一个线程循环的去执行任务
2、测试条件,调度器启动三个线程,然后两个线程去执行任务,一个添加任务
3、继续测试,启动十个线程,一个添加任务,九个执行任务
4、我们添加一些阻塞的任务
执行可以看到完全不可用
1、 可以看到随着M的不断的增加,可以发现执行任务的数量也不断的减少,原因是什么呢?有兴趣的同学可以加一个pprof可以看看,其实大量的在等待锁的过程!
2、如果我的M运行了类似于Sleep *** 作的方法如何解决了,我的调度器还能支撑这个量级的调度吗?
关于pprof如何使用:在代码头部加一个这个代码:
我们查看一下 go tool pprof main/profpporf
可以看到真正执行代码的时间只有 017s + 002s 其他时间都被阻塞掉了!
1、GM模型中的所有G都是放入到一个queue,那么导致所有的M取执行任务时都会去竞争锁,我们插入G也会去竞争锁,所以解决这种问题一般就是减少对单一资源的竞争,那就是桶化,其实就是每个线程都分配一个队列
2、GM模型中没有任务状态,只有runnable,假如任务遇到阻塞,完全可以把任务挂起再唤醒
这里其实会遇到一个问题,假如要分配很多个线程,那么此时随着线程的增加,也会造成队列的增加,其实也会造成调度器的压力,因为它需要遍历全部线程的队列去分配任务以及后续会讲到的窃取任务!
因为我们知道CPU的最大并行度其实取决于CPU的核数,也就是我们没必要为每个线程都去分配一个队列,因为就算是给他们分配了,他们自己去那执行调度,其实也会出现大量阻塞,原因就是CPU调度不过来这些线程!
Go里面是只分配了CPU个数的队列,这里就是P这个概念,你可以理解为P其实是真正的资源分配器,M很轻只是执行程序,所有的资源内存都维护在P上!M只有绑定P才能执行任务(强制的)!
这样做的好处:
1、首先调度程序其实就是调度不同状态的任务,go里面为Go标记了不同的状态,其实大概就是分为:runnable,running,block等,所以如何充分调度不同状态的G成了问题,那么关于阻塞的G如何解决,其实可以很好的解决G调度的问题!
上面这些情况其实就分为:
2、用户态阻塞,一般Go里面依靠 gopark 函数去实现,大体的代码逻辑基本上和go的调度绑定死了
源码在:>
Go 语言较之 C 语言一个很大的优势就是自带 GC 功能,可 GC 并不是没有代价的。写 C 语言的时候,在一个函数内声明的变量,在函数退出后会自动释放掉,因为这些变量分配在栈上。如果你期望变量的数据可以在函数退出后仍然能被访问,就需要调用 malloc 方法在堆上申请内存,如果程序不再需要这块内存了,再调用 free 方法释放掉。Go 语言不需要你主动调用 malloc 来分配堆空间,编译器会自动分析,找出需要 malloc 的变量,使用堆内存。编译器的这个分析过程就叫做逃逸分析。
所以你在一个函数中通过 dict := make(map[string]int) 创建一个 map 变量,其背后的数据是放在栈空间上还是堆空间上,是不一定的。这要看编译器分析的结果。
可逃逸分析并不是百分百准确的,它有缺陷。有的时候你会发现有些变量其实在栈空间上分配完全没问题的,但编译后程序还是把这些数据放在了堆上。如果你了解 Go 语言编译器逃逸分析的机制,在写代码的时候就可以有意识地绕开这些缺陷,使你的程序更高效。
Go 语言虽然在内存管理方面降低了编程门槛,即使你不了解堆栈也能正常开发,但如果你要在性能上较真的话,还是要掌握这些基础知识。
这里不对堆内存和栈内存的区别做太多阐述。简单来说就是, 栈分配廉价,堆分配昂贵。 栈空间会随着一个函数的结束自动释放,堆空间需要时间 GC 模块不断地跟踪扫描回收。如果对这两个概念有些迷糊,建议阅读下面 2 个文章:
这里举一个小例子,来对比下堆栈的差别:
stack 函数中的变量 i 在函数退出会自动释放;而 heap 函数返回的是对变量 i 的引用,也就是说 heap() 退出后,表示变量 i 还要能被访问,它会自动被分配到堆空间上。
他们编译出来的代码如下:
逻辑的复杂度不言而喻,从上面的汇编中可看到, heap() 函数调用了 runtimenewobject() 方法,它会调用 mallocgc 方法从 mcache 上申请内存,申请的内部逻辑前面文章已经讲述过。堆内存分配不仅分配上逻辑比栈空间分配复杂,它最致命的是会带来很大的管理成本,Go 语言要消耗很多的计算资源对其进行标记回收(也就是 GC 成本)。
Go 编辑器会自动帮我们找出需要进行动态分配的变量,它是在编译时追踪一个变量的生命周期,如果能确认一个数据只在函数空间内访问,不会被外部使用,则使用栈空间,否则就要使用堆空间。
我们在 go build 编译代码时,可使用 -gcflags '-m' 参数来查看逃逸分析日志。
以上面的两个函数为例,编译的日志输出是:
日志中的 &i escapes to heap 表示该变量数据逃逸到了堆上。
需要使用堆空间,所以逃逸,这没什么可争议的。但编译器有时会将 不需要 使用堆空间的变量,也逃逸掉。这里是容易出现性能问题的大坑。网上有很多相关文章,列举了一些导致逃逸情况,其实总结起来就一句话:
多级间接赋值容易导致逃逸 。
这里的多级间接指的是,对某个引用类对象中的引用类成员进行赋值。Go 语言中的引用类数据类型有 func , interface , slice , map , chan , Type(指针) 。
记住公式 DataField = Value ,如果 Data , Field 都是引用类的数据类型,则会导致 Value 逃逸。这里的等号 = 不单单只赋值,也表示参数传递。
根据公式,我们假设一个变量 data 是以下几种类型,相应的可以得出结论:
下面给出一些实际的例子:
如果变量值是一个函数,函数的参数又是引用类型,则传递给它的参数都会逃逸。
上例中 te 的类型是 func(int) ,属于引用类型,参数 int 也是引用类型,则调用 te(&j) 形成了为 te 的参数(成员) int 赋值的现象,即 tei = &j 会导致逃逸。代码中其他几种调用都没有形成 多级间接赋值 情况。
同理,如果函数的参数类型是 slice , map 或 interface{} 都会导致参数逃逸。
匿名函数的调用也是一样的,它本质上也是一个函数变量。有兴趣的可以自己测试一下。
只要使用了 Interface 类型(不是 interafce{} ),那么赋值给它的变量一定会逃逸。因为 interfaceVariableMethod() 先是间接的定位到它的实际值,再调用实际值的同名方法,执行时实际值作为参数传递给方法。相当于 interfaceVariableMethodthis = realValue
向 channel 中发送数据,本质上就是为 channel 内部的成员赋值,就像给一个 slice 中的某一项赋值一样。所以 chan Type , chan map[Type]Type , chan []Type , chan interface{} 类型都会导致发送到 channel 中的数据逃逸。
这本来也是情理之中的,发送给 channel 的数据是要与其他函数分享的,为了保证发送过去的指针依然可用,只能使用堆分配。
可变参数如 func(arg string) 实际与 func(arg []string) 是一样的,会增加一层访问路径。这也是 fmtSprintf 总是会使参数逃逸的原因。
例子非常多,这里不能一一列举,我们只需要记住分析方法就好,即,2 级或更多级的访问赋值会 容易 导致数据逃逸。这里加上 容易 二字是因为随着语言的发展,相信这些问题会被慢慢解决,但现阶段,这个可以作为我们分析逃逸现象的依据。
下面代码中包含 2 种很常规的写法,但他们却有着很大的性能差距,建议自己想下为什么。
Benchmark 和 pprof 给出的结果:
熟悉堆栈概念可以让我们更容易看透 Go 程序的性能问题,并进行优化。
多级间接赋值会导致 Go 编译器出现不必要的逃逸,在一些情况下可能我们只需要修改一下数据结构就会使性能有大幅提升。这也是很多人不推荐在 Go 中使用指针的原因,因为它会增加一级访问路径,而 map , slice , interface{} 等类型是不可避免要用到的,为了减少不必要的逃逸,只能拿指针开刀了。
大多数情况下,性能优化都会为程序带来一定的复杂度。建议实际项目中还是怎么方便怎么写,功能完成后通过性能分析找到瓶颈所在,再对局部进行优化。
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)