golang 线程 Java线程_Golang 学习笔记(06)—— 多线程
Golang
介绍
线程是cpu调度的最小单位,只有不同的线程才能同时在多核cpu上同时运行。但线程太占资源,线程调度开销大。go中的goroutine是一个轻量级的线程,执行时只需要4-5k的内存,比线程更易用,更高效,更轻便,调度开销比线程小,可同时运行上千万个并发。
go语言中开启一个goroutine非常简单,go函数名(),就开启了个线程。
默认情况下,调度器仅使用单线程,要想发挥多核处理器的并行处理能力,必须调用runtine.GOMAXPROCS(n)来设置可并发的线程数,也可以通过设置环境变量GOMAXPROCS打到相同的目的。
goroutine
Runtime包中提供了几个与goroutine相关的函数。Gosched()让当前正在执行的goroutine放弃CPU执行权限。调度器安排其他正在等待的线程运行。
请看以下例子:
package main
import (
"runtime"
"fmt"
)
func main(){
go sayHello()
go sayWorld()
var str string
fmt.Scan(&str)
}
func sayHello(){
for i := 0; i < 10; i++{
fmt.Print("hello ")
runtime.Gosched()
}
}
func sayWorld(){
for i := 0; i < 10; i++ {
fmt.Println("world")
runtime.Gosched()
}
}
运行结果
从上面输出结果可知,我们启动了两个线程,其中一个线程输出一句后调用Gosched函数,释放CPU权限;之后另一个线程获得CPU权限。这样两个线程交替获得cpu权限,才输出了以上结果。
runtime.NumCPU()返回了cpu核数,runtime.NumGoroutine()返回当前进程的goroutine线程数。即便我们没有开启新的goroutine。
package main
import (
"runtime"
"fmt"
)
func main(){
fmt.Println(runtime.NumCPU())
fmt.Println(runtime.NumGoroutine())
}
运行结果
runtime.Goexit()函数用于终止当前的goroutine,单defer函数将会继续被调用。
package main
import (
"runtime"
"fmt"
)
func test(){
defer func(){
fmt.Println(" in defer")
}()
for i := 0; i < 10; i++{
fmt.Print(i)
if i > 5{
runtime.Goexit()
}
}
}
func main(){
go test()
var str string
fmt.Scan(&str)
}
运行结果
在这里大家或许有个疑问,下面这两句代码干嘛的呢
var str string
fmt.Scan(&str)
这两句代码是等待输入的意思,在这里用来阻止主线程关闭的。如果没有这两句的话,会发现我们的程序瞬间就结束了,而且什么都没有输出。这是因为主线程关闭之后,所有开启的goroutine都会强制关闭,他还没有来得及输出,就结束了。
但是这样感觉怪怪的。如果有一种机制,在子线程结束的时候通知一下主线程,然后主线程再关闭,岂不是更好,这样就不用无休止的等待了。于是就有了channel。
channel
goroutine之间通过channel来通讯,可以认为channel是一个管道或者先进先出的队列。你可以从一个goroutine中向channel发送数据,在另一个goroutine中取出这个值。
使用make创建
var channel chan int = make(chan int)
// 或
channel := make(chan int)
生产者/消费者是最经典的使用示例。生产者goroutine负责将数据放入channel,消费者goroutine从channel中取出数据进行处理。
package main
import (
"fmt"
)
func main(){
buf:=make(chan int)
flg := make(chan int)
go producer(buf)
go consumer(buf, flg)
}
func producer(c chan int){
defer close(c) // 关闭channel
for i := 0; i < 10; i++{
c
}
}
func consumer(c, f chan int){
for{
if v, ok :=
fmt.Print(v) // 阻塞,直到生产者放入数据后继续读取数据
}else{
break
}
}
f
}
运行结果
可以将channel指定为单向通信。比如
func producer(c chan
defer close(c) // 关闭channel
for i := 0; i < 10; i++{
c
}
}
func consumer(c
for{
if v, ok :=
fmt.Print(v) // 阻塞,直到生产者放入数据后继续读取数据
}else{
break
}
}
f
}
channle可以是带缓冲的。make的第二个参数作为缓冲长度来初始化一个带缓冲的channel:
c := make(chan int, 5)
向带缓冲的channel发送数据时,只有缓冲区满时,发送操作才会被阻塞。当缓冲区空时,接收才会阻塞。
可以通过以下程序调整发送和接收的顺序调试
package main
import (
"fmt"
)
func main(){
c := make(chan int, 2)
c
c
fmt.Println(
fmt.Println(
}
select
如果有多个channel需要监听,可以考虑用select,随机处理一个可用的channel
package main
import (
"fmt"
)
func main(){
c := make(chan int)
quit := make(chan int)
go func(){
for i := 0; i < 10; i++{
fmt.Printf("%d ",
}
quit
}()
testMuti(c, quit)
}
func testMuti(c, quit chan int){
x, y := 0, 1
for {
select{
case c
x, y = y, x+y
case
fmt.Print("\nquit")
return
}
}
}
运行结果
channle超时机制
当一个channel被read/write阻塞时,会被一直阻塞下去,直到channel关闭。产生一个异常退出程序。channel内部没有超时的定时器。但我们可以用select来实现channel的超时机制
package main
import (
"time"
"fmt"
)
func main(){
c := make(chan int)
select{
case
fmt.Println("没有数据")
case
fmt.Println("超时退出")
}
}
运行结果
线程同步
假设现在我们有两个线程,一个线程写文件,一个线程读文件。如果在读文件的同时,写文件的线程向文件中写数据,就会出现问题。为了保证能够正确的读写文件,在读文件的时候,不能进行写入文件的操作,在写入时,不能进行读的操作。这就需要互斥锁。互斥锁是线程间同步的一种机制,用了保证在同一时刻只用一个线程访问共享资源。go中的互斥锁在sync包中。下面是个线程安全的map:
package main
import (
"errors"
"sync"
"fmt"
)
func main(){
m := &MyMap{mp:make(map[string]int), mutex:new(sync.Mutex)}
go SetValue(m)
go m.Display()
var str string
fmt.Scan(&str)
}
type MyMap struct{
mp map[string]int
mutex *sync.Mutex
}
func (this *MyMap)Get(key string)(int, error){
this.mutex.Lock()
i, ok := this.mp[key]
this.mutex.Unlock()
if !ok{
return i, errors.New("不存在")
}
return i, nil
}
func (this *MyMap)Set(key string, val int){
this.mutex.Lock()
defer this.mutex.Unlock()
this.mp[key] = val
}
func (this *MyMap)Display(){
this.mutex.Lock()
defer this.mutex.Unlock()
for key, val := range this.mp{
fmt.Println(key, "=", val)
}
}
func SetValue(m *MyMap){
var a rune
a = 'a'
for i := 0; i< 10; i++{
m.Set(string(a+rune(i)), i)
}
}
运行结果
完
golang 线程 Java线程_Golang 学习笔记(06)—— 多线程相关推荐
- JAVA高并发学习笔记(二) 多线程基础
1.1什么是线程 线程是进程(程序在计算机上的一次执行活动)内的执行单元 进程是以独立于其他进程的方式运行的,进程间是互相隔离的.一个进程无法直接访问另一个进程的数据.进程的资源诸如内存和CPU时间片 ...
- Java并发编程学习笔记(二)多线程的理解及多线程的优点
多线程的优点 原文:http://tutorials.jenkov.com/java-concurrency/benefits.html 作者:Jakob Jenkov 翻译:古圣昌 ...
- Java 线程同步与死锁 学习笔记
Java 线程同步与死锁 学习笔记 Java 线程同步与死锁 学习笔记 1 多线程共享数据 2 线程同步 3 同步准则 4 线程死锁 1. 多线程共享数据 在多线程操作中,多个线程可能同时处理同一个资 ...
- Java日志框架学习笔记
Java日志框架学习笔记 文章目录 0 主流Java日志框架 1 log4j 1.1 理论知识 1.1.1 Loggers日志记录器 1.1.2 Appenders输出端 1.1.3 Layout日志 ...
- java/android 设计模式学习笔记(1)--- 单例模式
前段时间公司一些同事在讨论单例模式(我是最渣的一个,都插不上嘴 T__T ),这个模式使用的频率很高,也可能是很多人最熟悉的设计模式,当然单例模式也算是最简单的设计模式之一吧,简单归简单,但是在实际使 ...
- Java 8 实战学习笔记
Java 8 实战学习笔记 @(JAVASE)[java8, 实战, lambda] 文章目录 Java 8 实战学习笔记 参考内容 Lambda表达式 Lambda环绕执行模式(抽离步骤) 原始代码 ...
- ESP32 单片机学习笔记 - 06 - (以太网)Ethernet转Wifi
ESP32 单片机学习笔记 - 06 - (以太网)Ethernet转Wifi 暂停了半个多月的学习,去调车了.现在课设开始了,赶紧回来把一开始的"以太网"目标学完.但是却发现,好 ...
- java/android 设计模式学习笔记(8)---桥接模式
这篇博客我们来介绍一下桥接模式(Bridge Pattern),它也是结构型设计模式之一.桥接,顾名思义,就是用来连接两个部分,使得两个部分可以互相通讯或者使用,桥接模式的作用就是为被分离了的抽象部分 ...
- java/android 设计模式学习笔记(1)---单例模式
前段时间公司一些同事在讨论单例模式(我是最渣的一个,都插不上嘴 T__T ),这个模式使用的频率很高,也可能是很多人最熟悉的设计模式,当然单例模式也算是最简单的设计模式之一吧,简单归简单,但是在实际使 ...
- Java之多线程学习笔记五 —— 多线程模拟龟兔赛跑
Java之多线程学习笔记五 -- 多线程模拟龟兔赛跑 参考教程B站狂神https://www.bilibili.com/video/BV1V4411p7EF package pers.ylw.less ...
最新文章
- OC高级编程——深入block,如何捕获变量,如何存储在堆上
- Apache Commons包 StringUtils工具类深入整理(转载)
- modelsim仿真中 do文件的写法技巧
- python自动化办公pdf-基于python实现自动化办公学习笔记
- 这个网站绝了,收录近600条Linux系统命令
- 【MySQL】查看MySQL配置文件路径及相关配置
- Jenkins 权限配置与集群配置
- linux软件读取不到空间,Linux下Oracle软件、数据文件等所在的磁盘分区空间不足的解决思路...
- 技术实践丨React Native 项目 Web 端同构
- JavaScript 原型总结三 函数和对象的关系
- 基于阿里云的MQTT远程控制
- 【转】响应式布局和自适应布局详解
- vb mysql 教程_[转载]VB.net教程之数据库简单操作
- github 仓库中文名_Github仓库重命名
- Eclipse快捷键的设置和使用(大小写快捷键等)
- html渐变生成,css gradient 在线渐变生成工具
- python3怎么将函数的用法通过help导出到文件
- C# 读写xml、excel、word、ppt、access
- PDF怎么转换成长图
- 驭梦KTV点歌系统简介