ARTS 第13周

ARTS 第13周分享

[TOC]

Algorithm

双链表的实现

难度:[easy]

[参考代码]

type heroNode2 struct {
 No int
 Name string
 NickName string
 front *heroNode2
 next *heroNode2
}
type DoubleLinkList struct {
 head *heroNode2
}
func NewHero2(no int, name, nickName string) *heroNode2 {
 return &heroNode2{No: no, Name: name, NickName: nickName}
}
func NewDoubleLink() DoubleLinkList {
 return DoubleLinkList{NewHero2(0, "", "")}
}
func (d *DoubleLinkList) add(hero *heroNode2) {
 tmp := d.head
 for tmp.next != nil {
 tmp = tmp.next
 }
 hero.front = tmp
 tmp.next = hero
}
func (d *DoubleLinkList) addOrder(hero *heroNode2) {
 tmp := d.head
 flag := false
 for {
 if tmp.No == hero.No {
 fmt.Println("have this Node...")
 return
 } else if tmp.No > hero.No {
 flag = true
 break
 }
 if tmp.next == nil {
 break
 }
 tmp = tmp.next
 }
 if flag {
 tmp.front.next = hero
 hero.front = tmp.front
 tmp.front = hero
 hero.next = tmp
 } else {
 tmp.next = hero
 hero.front = tmp
 }
}
func (d *DoubleLinkList) list() {
 if d.head.next == nil {
 fmt.Println("empty double list")
 return
 }
 tmp := d.head.next
 for tmp != nil {
 fmt.Printf("No: %d\tName: %s\tNickName: %s\n", tmp.No, tmp.Name, tmp.NickName)
 tmp = tmp.next
 }
}
func (d *DoubleLinkList) delete(hero *heroNode2) {
 if d.head.next == nil {
 fmt.Println("empty double list")
 return
 }
 tmp := d.head.next
 flag := false
 for tmp != nil {
 if tmp.No == hero.No {
 flag = true
 break
 }
 }
 if flag {
 tmp.front.next = tmp.next
 if tmp.next != nil {
 tmp.next.front = tmp.front
 }
 } else {
 fmt.Println("doesn't have this hero...")
 }
}
func (d *DoubleLinkList) update(hero *heroNode2) {
 if d.head.next == nil {
 fmt.Println("empty double list")
 return
 }
 tmp := d.head.next
 for tmp != nil {
 if tmp.No == hero.No {
 tmp.Name = hero.Name
 tmp.NickName = hero.NickName
 break
 }
 tmp = tmp.next
 }
}
func (d *DoubleLinkList) count() int {
 count := 0
 tmp := d.head
 for tmp.next != nil {
 count++
 tmp = tmp.next
 }
 return count
}
func (d *DoubleLinkList) reverse() {
 if d.head.next == nil || d.head.next.next == nil {
 return
 }
 //遍历这个list,将每一元素取出,插入新list的头结点后面
 pCur := d.head.next
 pNext := pCur.next
 newDouble := NewDoubleLink()
 for {
 fmt.Println(pCur, pNext)
 if newDouble.head.next == nil {
 fmt.Println("first---------")
 newDouble.head.next = pCur
 pCur.front = newDouble.head
 newDouble.list()
 fmt.Println("----------")
 d.list()
 } else {
 pCur.next = newDouble.head.next
 pCur.front = newDouble.head
 newDouble.head.next.front = pCur
 newDouble.head.next = pCur
 newDouble.list()
 }
 pCur = pNext
 if pCur == nil {
 break
 }
 pNext = pNext.next
 }
 d.head = newDouble.head
 log.Fatal()
}
func (d *DoubleLinkList) reIndex(num int) *heroNode2 {
 if d.head.next == nil {
 fmt.Println("empty double linklist")
 return nil
 }
 if d.count()-1 < num {
 fmt.Println("invalid index")
 return nil
 }
 tmp := d.head.next
 for tmp.next != nil {
 tmp = tmp.next
 }
 for i := 0; i < num; i++ {
 tmp = tmp.front
 }
 return tmp
}
func (d *DoubleLinkList) reList() {
 if d.head.next == nil {
 fmt.Println("empty link list")
 return
 }
 tmp := d.head.next
 for tmp.next != nil {
 tmp = tmp.next
 }
 for tmp != d.head {
 fmt.Printf("No: %d\tName: %s\tNickName: %s\n", tmp.No, tmp.Name, tmp.NickName)
 tmp = tmp.front
 }
}
func (d *DoubleLinkList) reList2() {
 d.reverse()
 d.list()
 d.reverse()
}

Review

Error Handling In Go, Part Ihttps://www.ardanlabs.com/blog/2014/10/error-handling-in-go-part-i.html

主要讲golang中的错误处理

Tips

学会聆听,职场最重要的事情https://mp.weixin.qq.com/s/j0dzIBKJMzXJJh6gm6QJog

https://mp.weixin.qq.com/s/j0dzIBKJMzXJJh6gm6QJog

画外音:帮助下属成长和提升,是leader的核心职责。

第一层聆听:下载式聆听(downloading)

说明:这类聆听,通常会根据自己的经验和习惯做出应激性反应,
它只会听到自己认可的部分,
默认忽略自己经验之外的部分,还对这些部分做主观评判,
这类聆听以自我为中心。

第二层聆听:看到事实(factual listening)

说明:这类聆听,
不仅能听到自己认可的部分,还能听到自己已有认知以外的部分,
这类聆听以事实为中心。

第三层聆听:同理心(empathic listening)

说明:这类聆听,不仅能听到事实,
还能以对方的视角,建立情感连接,
尝试去理解述说者背后的情感与逻辑,以便更好的体会为什么会说这样的话。
这类聆听以倾诉者为中心。

关键词:

对方视角(seeing through another persion's eyes)

情感连接(emotional connection)

画外音:这类聆听,更够更好的理解别人的语言与行为。

第四层聆听:生成性聆听(generative listening)

说明:前三层聆听,看到自己的认知,看到自己认知外的事实,尝试理解对方。第四次聆听,
是以发展的为中心,尝试了解对方的本心(source),
并看到帮ta走向自己本心的方法,扩大彼此认知的方法。

Share

mysql 缓冲池(buffer pool):https://mp.weixin.qq.com/s/nA6UHBh87U774vu4VvGhyw

https://mp.weixin.qq.com/s/nA6UHBh87U774vu4VvGhyw

应用系统分层架构,为了加速数据访问,会把最常访问的数据,放在缓存(cache)里,避免每次都去访问数据库。

缓存表数据与索引数据,把磁盘上的数据加载到缓冲池,避免每次访问都进行磁盘IO,起到加速访问的作用。

缓存访问快,但容量小

内存访问快,但容量小

以"最大限度"的降低磁盘访问

磁盘读写,并不是按需读取,而是按页读取,一次至少读一页数据(一般是4K)

数据访问,通常都遵循"集中读写"的原则,使用一些数据,大概率会使用附近的数据,这就是所谓的"局部性原理",它表明提前加载是有效的,确实能够减少磁盘IO。

磁盘访问按页读取能够提高性能,所以缓冲池一般也是按页缓存数据;

预读机制启示了我们,能把一些"可能要访问"的页提前加入缓冲池,避免未来的磁盘IO操作;

画外音:为了减少数据移动,LRU一般用链表实现。

由于预读(Read-Ahead),提前把页放入了缓冲池,但最终MySQL并没有从页中读取数据,称为预读失效。

画外音:但也不要因噎废食,因为害怕预读失败而取消预读策略,大部分情况下,局部性原理是成立的,预读是有效的。

当某一个SQL语句,要批量扫描大量数据时,可能导致把缓冲池的所有页都替换出去,导致大量热数据被换出,MySQL性能急剧下降,这种情况叫缓冲池污染。

这类like不能命中索引,必须全表扫描,就需要访问大量的页:

1.把页加到缓冲池(插入老生代头部);
2.从页里读出相关的row(插入新生代头部);

如此一来,所有的数据页都会被加载到新生代的头部,但只会访问一次,真正的热数据被大量换出。

MySQL缓冲池加入了一个"老生代停留时间窗口"的机制:

(1)假设T=老生代停留时间窗口;

(2)插入老生代头部的页,即使立刻被访问,并不会立刻放入新生代头部;

(3)只有满足"被访问"并且"在老生代停留时间"大于T,才会被放入新生代头部;

加入"老生代停留时间窗口"策略后,短时间内被大量加载的页,并不会立刻插入新生代头部,而是优先淘汰那些,短期内仅仅访问了一次的页。

而只有在老生代呆的时间足够久,停留时间大于T,才会被插入新生代头部。

参数:innodb_buffer_pool_size

介绍:配置缓冲池的大小,在内存允许的情况下,DBA往往会建议调大这个参数,越多数据和索引放到内存里,数据库的性能会越好。

参数:innodb_old_blocks_pct

介绍:老生代占整个LRU链长度的比例,默认是37,即整个LRU中新生代与老生代长度比例是63:37。

画外音:如果把这个参数设为100,就退化为普通LRU了。

参数:innodb_old_blocks_time

介绍:老生代停留时间窗口,单位是毫秒,默认是1000,即同时满足"被访问"与"在老生代停留时间超过1秒"两个条件,才会被插入到新生代头部。

总结

(1)缓冲池(buffer pool)是一种常见的降低磁盘访问的机制;

(2)缓冲池通常以页(page)为单位缓存数据;

(3)缓冲池的常见管理算法是LRU,memcache,OS,InnoDB都使用了这种算法;

(4)InnoDB对普通LRU进行了优化:

将缓冲池分为老生代和新生代,入缓冲池的页,优先进入老生代,页被访问,才进入新生代,以解决预读失效的问题

页被访问,且在老生代停留时间超过配置阈值的,才进入新生代,以解决批量数据访问,大量热数据淘汰的问题

思路,比结论重要。

本周阅读

第4周:1, 2, 3, 4, 
缓冲池(buffer pool),这次彻底懂了!!!https://mp.weixin.qq.com/s/nA6UHBh87U774vu4VvGhyw
什么叫CQRS!https://mp.weixin.qq.com/s/-9TS3p7gSvrS3P3vOM81YQ
学会聆听,职场最重要的事情:https://mp.weixin.qq.com/s/j0dzIBKJMzXJJh6gm6QJog
Go 语言中的错误处理 - 第二部分:https://mp.weixin.qq.com/s/nxtEB6q3jophnnnvQaYNDA
Error Handling In Go, Part I: https://www.ardanlabs.com/blog/2014/10/error-handling-in-go-part-i.html
拓扑排序原理与解题套路:https://mp.weixin.qq.com/s/r2Sf0I0JarpXmvBlX_1LTg
Libra:Facebook的"野心"?https://mp.weixin.qq.com/s/4-RqXa0hQ-f77DVj8r3RYg
git 上的pull request 是什么意思?https://www.cnblogs.com/zhaoyanjun/p/5134274.html
什么叫CQRS!https://mp.weixin.qq.com/s/-9TS3p7gSvrS3P3vOM81YQ

有疑问加站长微信联系(非本文作者)

• 请尽量让自己的回复能够对别人有帮助
• 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
• 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
• 图片支持拖拽、截图粘贴等方式上传