关键词:
进程和线程
A。进程是程序在操作系统中的一次执行过程,系统进行资源分配和调度的一个独立单位。
B。线程是进程的一个执行实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。
C。一个进程可以创建和撤销多个线程;同一进程中的多个线程之间可以并发执行。
并发和并行
并发:多线程程序在一个核的cpu上运行
并行:多线程程序在多个核的cpu上运行
举例。。一个妈给一个碗给多个小孩喂饭,,是并发
一个妈给每个小孩一人一个碗,就是并行
并发 并行
协程和线程
协程:独立的栈空间,共享堆空间,调度由用户自己控制,本质上有点类似于用户级协程,这些用户级线程的调度也是自己实现的。
线程:一个线程上可以跑多个协程,协程是轻量级的线程。
例子
package main import ( "fmt" "time" ) func test() { var i int for { fmt.Println(i) time.Sleep(time.Second) i++ } } func main() { go test() //起一个协程执行test() for { fmt.Println("i : runnging in main") time.Sleep(time.Second ) } }
-
--
设置Golang运行的cpu核数。
1.8版本以上,默认跑多个核
package main import ( "fmt" "runtime" ) func main() { num := runtime.NumCPU() runtime.GOMAXPROCS(num) fmt.Println(num) }
并发计算
package main import ( "fmt" "sync" "time" ) var ( m = make(map[int]uint64) lock sync.Mutex ) type task struct { n int } func calc(t *task) { var sum uint64 sum = 1 for i := 1; i < t.n; i++ { sum *= uint64(i) } fmt.Println(t.n, sum) lock.Lock() m[t.n] = sum lock.Unlock() } func main() { for i := 0; i < 16; i++ { t := &task{n: i} go calc(t)//并发执行,谁快谁先出 } time.Sleep(10 * time.Second) //lock.Lock() //for k, v := range m { // fmt.Printf("%d!=%v\n", k, v) //} //lock.Unlock() }
Channel
channel概念
a。类似unix中的管道(pipe)
b.先进先出
c。线程安全,多个goroutine同时访问,不需要枷锁
d。channel是有类型的,一个整数的channel只能存整数
channel声明
var name chan string var age chan int var mapchan chan map[string]string var test chan student var test1 chan *student
channel初始化
使用make进行初始化 var test chan int test = make(chan int,10) var test chan string test=make(chan string,10)
channel基本操作
从channel读取数据
var testChan chan int testChan = make(chan int, 10) var a int a = <-testChan
-从channel写入数据
var testChan chan int testChan = make(chan int, 10) var a int = 10 testChan <- a
第一个例子
package main import "fmt" type student struct { name string } func main() { var stuChan chan *student stuChan = make(chan *student, 10) stu := student{name: "stu001"} stuChan <- &stu var stu01 interface{} stu01 = <-stuChan var stu02 *student stu02, ok := stu01.(*student) if !ok { fmt.Println("can not convert") return } fmt.Println(stu02) }
goroutine与channel
package main import ( "fmt" "time" ) //起一个读的协程 func write(ch chan int) { for i := 0; i < 1000; i++ { ch <- i } } func read(ch chan int) { for { var b int b = <-ch fmt.Println(b) } } func main() { intChan := make(chan int, 10) go write(intChan) go read(intChan) time.Sleep(10 * time.Second) }
读,取,字符串
package main import ( "fmt" "time" ) func sendData(ch chan string) { ch <- "Washington" ch <- "Tripoli" ch <- "London" ch <- "Beijing" ch <- "Tokio" } func getData(ch chan string) { var input string for { input = <-ch fmt.Println(input) } } func main() { ch := make(chan string) go sendData(ch) go getData(ch) time.Sleep(3 * time.Second) }
Channel缓冲区
只能放一个元素的testChan var testChan chan int testChan = make(chan int) var a int a = <-testChan
-
testChan是带缓冲区的chan,一次可以放10个元素
var testChan chan int testChan = make(chan int, 10) var a int = 10 testChan <- a
-
package main import ( "fmt" "sync" "time" ) var ( m = make(map[int]uint64) lock sync.Mutex ) type task struct { n int } func calc(t *task) { var sum uint64 sum = 1 for i := 1; i < t.n; i++ { sum *= uint64(i) } fmt.Println(t.n, sum) lock.Lock() m[t.n] = sum lock.Unlock() } func main() { for i := 0; i < 16; i++ { t := &task{n: i} go calc(t) } time.Sleep(10 * time.Second) lock.Lock() for k, v := range m { fmt.Printf("%d!=%v\n", k, v) } lock.Unlock() }
package main import ( "fmt" ) func calc(taskChan chan int, resChan chan int, exitChan chan bool) { for v := range taskChan { flag := true for i := 2; i < v; i++ { if v%i == 0 { flag = false break } } if flag { resChan <- v } } fmt.Println("exit") exitChan <- true } func main() { intChan := make(chan int, 1000) resultChan := make(chan int, 1000) exitChan := make(chan bool, 8) go func() { for i := 0; i < 10000; i++ { intChan <- i } close(intChan) }() for i := 0; i < 8; i++ { go calc(intChan, resultChan, exitChan) } //等待所有计算的goroutine全部退出 go func() { for i := 0; i < 8; i++ { <-exitChan fmt.Println("wait goroute", i, "exited") } close(resultChan) }() for v := range resultChan { fmt.Println(v) } }
package main import "fmt" func send(ch chan int, exitChan chan struct{}) { for i := 0; i < 10; i++ { ch <- i } close(ch) var a struct{} exitChan <- a } func recv(ch chan int, exitChan chan struct{}) { for { v, ok := <-ch if !ok { break } fmt.Println(v) } var a struct{} exitChan <- a } func main() { var ch chan int ch = make(chan int, 10) exitChan := make(chan struct{}, 2) go send(ch, exitChan) go recv(ch, exitChan) var total = 0 for _ = range exitChan { total++ if total == 2 { break } } }
检测管道是否关闭
package main import "fmt" func main() { var ch chan int ch = make(chan int, 10) for i := 0; i < 10; i++ { ch <- i } close(ch) for { var b int b, ok := <-ch //检测管道是否关闭 if ok == false { fmt.Println("chan is close") break } fmt.Println(b) } }
如何关闭chan
1. 使用内置函数close进行关闭,chan关闭之后,for range遍历chan中 已经存在的元素后结束 2. 使用内置函数close进行关闭,chan关闭之后,没有使用for range的写法 需要使用,v, ok := <- ch进行判断chan是否关闭
chan的只读和只写
只读的声明 Var 变量的名字 <-chan int Var readChan <- chan int 只写的声明 Var 变量的名字 chan<- int Var writeChan chan<- int
package main import "fmt" //只写chan func send(ch chan<- int, exitChan chan struct{}) { for i := 0; i < 10; i++ { ch <- i } close(ch) var a struct{} exitChan <- a } //只读chan func recv(ch <-chan int, exitChan chan struct{}) { for { v, ok := <-ch if !ok { break } fmt.Println(v) } var a struct{} exitChan <- a } func main() { var ch chan int ch = make(chan int, 10) //初始化chan exitChan := make(chan struct{}, 2) go send(ch, exitChan) go recv(ch, exitChan) var total = 0 for _ = range exitChan { total++ if total == 2 { break } } }
不阻塞
package main import "fmt" import "time" func main() { var ch chan int ch = make(chan int, 10) ch2 := make(chan int, 10) go func() { var i int for { ch <- i time.Sleep(time.Second) ch2 <- i * i time.Sleep(time.Second) i++ } }() for { select { case v := <-ch: fmt.Println(v) case v := <-ch2: fmt.Println(v) case <-time.After(time.Second): fmt.Println("get data timeout") time.Sleep(time.Second) } } }
go语言学习之旅--并发编程
Go语言学习之旅--并发编程golang并发编程之协程golang并发编程之通道golang并发编程之WaitGroup实现同步golang并发编程之runtime包golang并发编程之Mutex互斥锁实现同步golang并发编程之channel的遍历golang并发编程之selectswitchgolang并发编程之T... 查看详情
go语言学习之旅--并发编程
Go语言学习之旅--并发编程golang并发编程之协程golang并发编程之通道golang并发编程之WaitGroup实现同步golang并发编程之runtime包golang并发编程之Mutex互斥锁实现同步golang并发编程之channel的遍历golang并发编程之selectswitchgolang并发编程之T... 查看详情
Codewalk之Golang并发代码回顾
】Codewalk之Golang并发代码回顾【英文标题】:GolangConcurrencyCodeReviewofCodewalk【发布时间】:2021-08-3021:27:38【问题描述】:我正在尝试了解Golang并发的最佳实践。我阅读了O\'Reilly关于Go并发的书,然后又回到了GolangCodewalks,特别是这... 查看详情
go语言入门篇-golang之文本编码处理
Golang之文本编码处理 查看详情
golang并发编程之生产者消费者(代码片段)
golang最吸引人的地方可能就是并发了,无论代码的编写上,还是性能上面,golang都有绝对的优势学习一个语言的并发特性,我喜欢实现一个生产者消费者模型,这个模型非常经典,适用于很多的并发场景,下面我通过这个模型,... 查看详情
golang入门到项目实战golang并发编程之runtime包
参考技术Aruntime包里面定义了一些协程管理相关的api让出CPU时间片,重新等待安排任务运行结果退出当前协程运行结果运行结果如果修改最大核心数为1,运行结果如下,不会出现交替执行现象 查看详情
golang之webassembly篇(代码片段)
解决Wasm和Js之间互调问题,程序猿直接上代码更清晰。DEMO项目结构分别贴出核心三个文件代码main.gopackagemainimport( "fmt" "learn/util" "syscall/js")funcmain() fmt. 查看详情
golang之webassembly篇(代码片段)
解决Wasm和Js之间互调问题,程序猿直接上代码更清晰。DEMO项目结构分别贴出核心三个文件代码main.gopackagemainimport( "fmt" "learn/util" "syscall/js")funcmain() fmt. 查看详情
golang数据结构之slice篇
packagemainimport"github.com/sanity-io/litter"funcmain() varsliceInt[]int //init sliceInt=append(sliceInt,[]int1,2,3,4...) litter.Dump(sliceInt) //removeindex0 sliceInt=append(sliceInt[:0],sliceInt 查看详情
golang并发编程之channel(代码片段)
一、概念channel是golang语言级别提供的协程(goroutine)之间的通信方式。goroutine运行在相同的地址空间,因此访问共享内存必须做好同步。那么goroutine之间如何进行数据的通信呢,Go提供了一个很好的通信机制channel。channel可以与Unixs... 查看详情
高并发场景之rabbitmq篇
上次我们介绍了在单机、集群下高并发场景可以选择的一些方案,传送门:高并发场景之一般解决方案但是也发现了一些问题,比如集群下使用ConcurrentQueue或加锁都不能解决问题,后来采用Redis队列也不能完全解决问题,因为使... 查看详情
测开之并发编程篇・《并发并行线程队列进程和协程》(代码片段)
并发编程并发和并行多任务概念并发和并行同步和异步多线程threading模块介绍自定义线程类线程任务函数的传递多线程资源共享和资源竞争问题GIL全局解释锁互斥锁通过锁解决资源竞争问题死锁队列队列的方法FIFO先入先出队列LI... 查看详情
3.高并发教程-基础篇-之分布式全文搜索引擎elasticsearch的搭建(代码片段)
高并发教程-基础篇-之分布式全文搜索引擎elasticsearch的搭建如果大家看了我的上一篇《2.高并发教程-基础篇-之nginx+mysql实现负载均衡和读写分离》文章,如果能很好的利用,那么其实已经可以轻松日抗千万级别的访问量了,但是... 查看详情
golang教程:goroutine信道(代码片段)
在上一篇教程中,我们讨论了如何使用协程实现并发。在这篇教程中,我们将讨论信道以及如何使用信道实现协程间通信。什么是信道信道(Channel)可以被认为是协程之间通信的管道。与水流从管道的一端流向另一端一样,数... 查看详情
java开发之高并发必备篇——线程安全操作之synchronized
提到并发编程大多数第一时刻想到的就是synchronized同步锁了,synchronized也是面试中问的比较多的一个问题。在之前的文章中我们提到过线程安全的三个特性:原子性、可见性和有序性,并且说到了java中定义了一个关... 查看详情
java开发之高并发必备篇——线程安全操作之synchronized
提到并发编程大多数第一时刻想到的就是synchronized同步锁了,synchronized也是面试中问的比较多的一个问题。在之前的文章中我们提到过线程安全的三个特性:原子性、可见性和有序性,并且说到了java中定义了一个关... 查看详情
java开发之高并发编程篇——安全访问的集合
CopyOnWriteArrayList和CopyOnWriteArrayList因为CopyOnWriteArraySet底层也是使用了CopyOnWriteArrayList来实现的,所以本篇文章以CopyOnWriteArrayList讲解为主。CopyOnWriteArrayList是JDK1.5之后提供的一个List接口的实现子类,位于java.util.co 查看详情
第36天并发编程之进程篇(代码片段)
目录: 1.基础概念 2.创建进程和结束进程 3. 进程之间内存空间物理隔离 4. 进程的属性方法 5.守护进程 6.互斥锁 7.IPC通信机制 8.生产者消费者模型一.基础概念1.什么叫做程序,什么叫做进程... 查看详情