Lecture 02 Infrastructure: RPC & threads

一、多线程挑战

  • 共享数据: 使用互斥信号量、或者避免共享
  • 线程间协作: 使用channels 或者 waitgroup 来等待所有map线程结束
  • 并发粒度:
    • 粗粒度: 简单,但是并发性不高
    • 细粒度: 更多的并发,但是处理复杂,可能会有更多的冲突和死锁

以下这段代码就能说明并发的粒度问题:

	constructTaskArgs := func(phase jobPhase, task int) DoTaskArgs {
debug("task: %d\n", task)
var taskArgs DoTaskArgs
taskArgs.Phase = phase
taskArgs.JobName = jobName
taskArgs.NumOtherPhase = n_other
taskArgs.TaskNumber = task
if phase == mapPhase {
taskArgs.File = mapFiles[task]
}
return taskArgs
} tasks := make(chan int) // act as task queue
go func() {
for i := 0; i < ntasks; i++ {
tasks <- i
}
}()
successTasks := 0
success := make(chan int) loop:
for {
select {
case task := <-tasks:
go func() {
worker := <-registerChan
status := call(worker, "Worker.DoTask", constructTaskArgs(phase, task), nil)
if status {
success <- 1
go func() { registerChan <- worker }()
} else {
tasks <- task
}
}()
case <-success:
successTasks += 1
default:
if successTasks == ntasks {
break loop
}
}
}

里面不仅使用了task的channel, 还使用了success (channel) 来控制 successTask 的共享。

二、爬虫并发的问题

网络是一个有环的图,但是我们设计爬虫需要避免环。

  • 一方面是因为重复遍历url,没有任何意义
  • 另一方面只访问一次url可以减轻目标服务器负担

单线程爬虫:

func Serial(url string, fetcher Fetcher, fetched map[string]bool) {
if fetched[url] {
return
}
fetched[url] = true
urls, err := fetcher.Fetch(url)
if err != nil {
return
}
for _, u := range urls {
Serial(u, fetcher, fetched)
}
return
}

2.1 并发互斥爬虫

因此需要维护一张visited表来记录是否遍历过url,这里就会出现并发问题。

当T1 检查visited[url] , T2也检查visited[url] 两个线程都会认为没有访问过该url,这时候就会发生冲突,发生WW(write + write) 。解决办法是,维护一个Mutex 互斥信号量来访问visited这张表。

  • 判断线程结束

使用sync.WaitGroup来保证线程执行完成

type fetchState struct {
mu sync.Mutex
fetched map[string]bool
} func ConcurrentMutex(url string, fetcher Fetcher, f *fetchState) {
f.mu.Lock()
if f.fetched[url] {
f.mu.Unlock()
return
}
f.fetched[url] = true
f.mu.Unlock() urls, err := fetcher.Fetch(url)
if err != nil {
return
}
var done sync.WaitGroup
for _, u := range urls {
done.Add(1)
go func(u string) {
defer done.Done()
ConcurrentMutex(u, fetcher, f)
}(u)
}
done.Wait()
return
} func makeState() *fetchState {
f := &fetchState{}
f.fetched = make(map[string]bool)
return f
}

2.2 并发通道爬虫

master启动worker去爬取url, worker将url送到同一个通道里面, master从通道获取url去爬取内容

共享的数据:

  • 通道
  • 发送到 通道的 slices 和 字符串
  • 从master发送到worker的参数
//
// Concurrent crawler with channels
// func worker(url string, ch chan []string, fetcher Fetcher) {
urls, err := fetcher.Fetch(url)
if err != nil {
ch <- []string{}
} else {
ch <- urls
}
} func master(ch chan []string, fetcher Fetcher) {
n := 1
fetched := make(map[string]bool)
for urls := range ch {
for _, u := range urls {
if fetched[u] == false {
fetched[u] = true
n += 1
go worker(u, ch, fetcher)
}
}
n -= 1
if n == 0 {
break
}
}
} func ConcurrentChannel(url string, fetcher Fetcher) {
ch := make(chan []string)
go func() {
ch <- []string{url}
}()
master(ch, fetcher)
}

三、什么时候使用共享空间和锁 vs 通道

state -- 共享空间和锁

communication -- 通道

waiting for events -- 通道

使用go 的 race dector

四、Remote Procedure Call(RPC)

4.1 软件架构:

客户端 handlers

stubs dispatcher(调度器)

rpc lib rpc lib


网络 ----- 网络

4.2 rpc过程:

  • 首先双方定义发送的参数, 和返回的结构体
  • 客户端 Dial()创建tcp连接请求 call() 调用rpc库来执行远程调用
  • 服务器 声明一个带返回方法的对象 作为rpc处理器, 然后使用rpc库的Register函数来注册服务, rpc库:
    • 读取每一个请求
    • 为每一个请求创建一个goroutine
    • 反序列化请求
    • 调用目标函数
    • 序列化返回值
    • 将返回值通过tcp连接返回

4.3rpc 示例

源码

client:

//
// Client
// func connect() *rpc.Client {
client, err := rpc.Dial("tcp", ":1234")
if err != nil {
log.Fatal("dialing:", err)
}
return client
} func get(key string) string {
client := connect()
args := GetArgs{"subject"}
reply := GetReply{}
err := client.Call("KV.Get", &args, &reply)
if err != nil {
log.Fatal("error:", err)
}
client.Close()
return reply.Value
} func put(key string, val string) {
client := connect()
args := PutArgs{"subject", "6.824"}
reply := PutReply{}
err := client.Call("KV.Put", &args, &reply)
if err != nil {
log.Fatal("error:", err)
}
client.Close()
}

server

//
// Server
// type KV struct {
mu sync.Mutex
data map[string]string
} func server() {
kv := new(KV)
kv.data = map[string]string{}
rpcs := rpc.NewServer()
rpcs.Register(kv)
l, e := net.Listen("tcp", ":1234")
if e != nil {
log.Fatal("listen error:", e)
}
go func() {
for {
conn, err := l.Accept()
if err == nil {
go rpcs.ServeConn(conn)
} else {
break
}
}
l.Close()
}()
} func (kv *KV) Get(args *GetArgs, reply *GetReply) error {
kv.mu.Lock()
defer kv.mu.Unlock() val, ok := kv.data[args.Key]
if ok {
reply.Err = OK
reply.Value = val
} else {
reply.Err = ErrNoKey
reply.Value = ""
}
return nil
} func (kv *KV) Put(args *PutArgs, reply *PutReply) error {
kv.mu.Lock()
defer kv.mu.Unlock() kv.data[args.Key] = args.Value
reply.Err = OK
return nil
}

4.3 rpc怎么处理失败

问题:

  • 网络延迟
  • 丢包
  • 服务器慢或者崩溃

处理办法:

  • best effort:

    • client调用call( ) 等待响应, 如果过了一会没收到响应那就再发送一个call( )
    • 这个过程重复几次,然后放弃并且返回一个错误
  • at most once:
    • 针对服务端说的:当服务端收到相同的请求时

      • 根据xid(client id 判断)如果收到相同请求 返回之前的处理结果
      • xid 怎么保证唯一性
  • exactly once:
    • 无限重试
    • 冗余检查
    • 容错服务

【MIT 6.824 】分布式系统 课程笔记(一)的更多相关文章

  1. 【MIT 6.824 】分布式系统 课程笔记(二)Lecture 03 : GFS

    Lecture 03 : GFS 一.一致性 1, 弱一致性 可能会读到旧数据 2, 强一致性 读到的数据都是最新的 3, 一致性比较 强一致性对于app的写方便, 但是性能差 弱一致性有良好的性能, ...

  2. MIT 6.824 lab1:mapreduce

    这是 MIT 6.824 课程 lab1 的学习总结,记录我在学习过程中的收获和踩的坑. 我的实验环境是 windows 10,所以对lab的code 做了一些环境上的修改,如果你仅仅对code 感兴 ...

  3. MIT 6.824(Spring 2020) Lab1: MapReduce 文档翻译

    首发于公众号:努力学习的阿新 前言 大家好,这里是阿新. MIT 6.824 是麻省理工大学开设的一门关于分布式系统的明星课程,共包含四个配套实验,实验的含金量很高,十分适合作为校招生的项目经历,在文 ...

  4. CS231n课程笔记翻译9:卷积神经网络笔记

    译者注:本文翻译自斯坦福CS231n课程笔记ConvNet notes,由课程教师Andrej Karpathy授权进行翻译.本篇教程由杜客和猴子翻译完成,堃堃和李艺颖进行校对修改. 原文如下 内容列 ...

  5. MIT 6.828 JOS学习笔记2. Lab 1 Part 1.2: PC bootstrap

    Lab 1 Part 1: PC bootstrap 我们继续~ PC机的物理地址空间 这一节我们将深入的探究到底PC是如何启动的.首先我们看一下通常一个PC的物理地址空间是如何布局的:        ...

  6. MIT 6.828 JOS学习笔记0. 写在前面的话

    0. 简介 操作系统是计算机科学中十分重要的一门基础学科,是一名计算机专业毕业生必须要具备的基础知识.但是在学习这门课时,如果仅仅把目光停留在课本上一些关于操作系统概念上的叙述,并不能对操作系统有着深 ...

  7. Linux内核分析课程笔记(一)

    linux内核分析课程笔记(一) 冯诺依曼体系结构 冯诺依曼体系结构实际上就是存储程序计算机. 从两个层面来讲: 从硬件的角度来看,冯诺依曼体系结构逻辑上可以抽象成CPU和内存,通过总线相连.CPU上 ...

  8. (1/18)重学Standford_iOS7开发_iOS概述_课程笔记

    写在前面:上次学习课程对iOS还是一知半解,由于缺乏实践,看公开课的视频有时不能很好地领会知识.带着问题去学习永远是最好的方法,接触一段时间iOS开发以后再来看斯坦福iOS公开课,又会有许多新的发现, ...

  9. Andrew Ng机器学习课程笔记(五)之应用机器学习的建议

    Andrew Ng机器学习课程笔记(五)之 应用机器学习的建议 版权声明:本文为博主原创文章,转载请指明转载地址 http://www.cnblogs.com/fydeblog/p/7368472.h ...

随机推荐

  1. cmake和json安装

    一.cmake源码安装 官网下载源码:https://cmake.org/download/ 安装: ./bootstrap make make install cmake --version 二.j ...

  2. 【多线程与并发】Java中的12个原子操作类

    从JDK1.5开始,Java提供了java.util.concurrent.atomic包,该包中的原子操作类提供了一种使用简单.性能高效(使用CAS操作,无需加锁).线程安全地更新一个变量的方式. ...

  3. [Android] 安卓手机不用root删除自带app

    声明:本文档仅供测试,因删除引起的一切问题,本人概不负责 声明:本文档仅供测试,因删除引起的一切问题,本人概不负责 声明:本文档仅供测试,因删除引起的一切问题,本人概不负责 转载请注明出处:https ...

  4. Mysql 按年、季度、月、周查询统计

    User表 CREATE TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID', `username` varchar( ...

  5. 屏幕录制 -- web前端

    前端使用html5.ffmpeg实现录屏摄像等功能 https://tong-h.github.io/2018/11/06/streamcapture/ JSCapture – 基于 HTML5 实现 ...

  6. uSurvival 1.41多人在线生存逃杀吃鸡类游戏源码

    uSurvival - the new Multiplayer Survival Asset from the creator of uMMORPG. Features:* Kill Zombies ...

  7. Intellij IDEA 2019 最新优化配置

    Intellij IDEA 2019 最新优化配置     转发自Dimple’s Blog 摘要: 之前在CSDN上写了一点关于IDEA的优化配置之类的文章,有些图片失效了,很多人都希望会有继续更新 ...

  8. TypeScript封装统一操作Mysql Mongodb Mssql的底层类库demo

    /* 功能:定义一个操作数据库的库 支持 Mysql Mssql MongoDb 要求1:Mysql MsSql MongoDb功能一样 都有 add update delete get方法 注意:约 ...

  9. linux硬盘分区与格式化

    linux硬盘分区与格式化: 1. 设备管理 在 Linux 中,每一个硬件设备都映射到一个系统的文件,对于硬盘.光驱等 IDE 或 SCSI 设备也不例外. Linux 把各种 IDE 设备分配了一 ...

  10. Qt tableview加载数据

    Qt tableview加载数据 //把数据加载到tableView void ImportData::loadDataInTableView() { ) { if (pageNum>stude ...