golang并发编程

最新推荐文章于 2023-08-03 23:21:38 发布
最新推荐文章于 2023-08-03 23:21:38 发布
阅读量4.8k 收藏 7
点赞数 1
分类专栏： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/e421083458/article/details/49739043
版权

golang普通方法：

package main

import (
	"fmt"
)

func rand_generator_1() int {
	return rand.Int()
}

func main() {
	fmt.Println(rand_generator_1())
}


golang生成器：

package main

import (
	"fmt"
	"math/rand"
)

/**
* 生成器
* 根据已知权限使用函数生成相应数据，异步调用节省了大量时间。
* @author: niuyufu
 */

func rand_generator_1() int {
	return rand.Int()
}

//直接返回通道channel
func rand_generator_2() chan int {
	//创建通道
	out := make(chan int)
	//创建携程
	go func() {
		//持续执行，直到程序被打断
		for {
			//向通道内写入数据，如果无人读取会等待
			out <- rand.Int()
		}
	}()
	return out
}

func main() {
	//生成随机数作为一个服务
	rand_service_handler := rand_generator_2()
	//从服务中读取随机数并打印
	fmt.Println("%dn", <-rand_service_handler)
	fmt.Println("%dn", <-rand_service_handler)
	fmt.Println("%dn", <-rand_service_handler)
}


golang多路复用，高并发版生成器：

package main

import (
	"fmt"
	"math/rand"
)

/**
* 多路复用，高并发版生成器
* 根据已知权限使用函数生成相应数据，异步调用节省了大量时间。
* @author: niuyufu
 */

func rand_generator_1() int {
	return rand.Int()
}

//直接返回通道channel
func rand_generator_2() chan int {
	//创建通道
	out := make(chan int)
	//创建携程
	go func() {
		//持续执行，直到程序被打断
		for {
			//向通道内写入数据，如果无人读取会等待
			out <- rand.Int()
		}
	}()
	return out
}

//函数 rand_generator_3,返回通道（channel）
func rand_generator_3() chan int {
	//创建两个随机数生成器服务
	rand_service_handler_1 := rand_generator_2()
	rand_service_handler_2 := rand_generator_2()
	//创建通道
	out := make(chan int)
	//创建协程
	go func() {
		for {
			//读取生成器1中的数据，整合
			out <- <-rand_service_handler_1
		}
	}()
	go func() {
		for {
			//读取生成器1中的数据，整合
			out <- <-rand_service_handler_2
		}
	}()
	return out
}
func main() {
	//生成随机数作为一个服务
	rand_service_handler := rand_generator_3()
	//从服务中读取随机数并打印
	fmt.Println("%dn", <-rand_service_handler)
	fmt.Println("%dn", <-rand_service_handler)
	fmt.Println("%dn", <-rand_service_handler)
}


golang之Furture技术

package main

import (
	"fmt"
)

/**
* Furture技术
* 在不准备好参数的情况下调用函数：这样的设计可以提供很大的自由度和并发度， 参数调用与参数调用完全解耦
* @author: niuyufu
 */

//一个查询结构体
type query struct {
	//参数channel
	sql chan string
	//结果channel
	result chan string
}

//执行query
func execQuery(q query) {
	//启动协程
	go func() {
		//获取输入
		sql := <-q.sql
		//访问数据库，输出结果通道
		q.result <- "get " + sql
	}()
}
func main() {
	//初始化Query
	q := query{make(chan string, 1), make(chan string, 1)}
	//执行Query，注意执行的时候无需准备参数
	execQuery(q)

	//准备参数
	q.sql <- "select * from table"
	//获取结果
	fmt.Println(<-q.result)
}


golang之并发循环

package main

import (
	"fmt"
)

/**
* 并发循环
* 并发一次性跑完N个任务，这个牛X
* @author: niuyufu
 */
func doSomething(i int, xi int) {
	fmt.Println("i=%d,xi=%d", i, xi)
}

func main() {
	//建立计数器
	//这里就好比有好多一次性需要处理完的任务
	data := []int{1, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3}
	N := len(data)
	sem := make(chan int, N)
	//经过这个for可以让cpu占满来跑你的任务
	for i, xi := range data {
		//建立协程
		go func(i int, xi int) {
			doSomething(i, xi)
			//计数
			sem <- 0
		}(i, xi)
	}
	fmt.Println("并发循环开始")
	//等待结束，查看跑完结果
	for i := 0; i < N; i++ {
		<-sem
	}
	fmt.Println("搞定了。")
}


golang之Chain Filter技术

package main

import (
	"fmt"
)

/**
* Chain Filter技术
* 并发过滤链，每个通道只有两个协程访问，性能良好
* @author: niuyufu
 */
func Generate(ch chan<- int) {
	for i := 2; ; i++ {
		//fmt.Println("Generate:i:", i)
		ch <- i
	}
}
func Filter(in <-chan int, out chan<- int, prime int) {
	for {
		//只有输出才能再创建
		i := <-in
		//fmt.Println("Filter:in pop:", i)
		if i%prime != 0 {
			//fmt.Println("Filter:out add:", i)
			out <- i
		}
	}
}

//
func main() {
	//result数组
	var numbers []int
	//channel大小为1
	ch := make(chan int)
	go Generate(ch) //generate的gorouine占用channel：ch，通道被占用一次
	for i := 0; i < 1000; i++ {
		prime := <-ch
		numbers = append(numbers, prime)
		fmt.Println(prime, "n")
		ch1 := make(chan int)
		go Filter(ch, ch1, prime) //Filter的gorouine也点用了channel:ch，通道被占用二次
		ch = ch1                  //打通两个通道
		//fmt.Println(<-ch1)
	}
	//fmt.Printf("len=%d cap=%d slice=%v\n", len(numbers), cap(numbers), numbers)
}


golang之共享变量

package main

import (
	"fmt"
	"time"
)

/**
* 共享变量
* 通过一个单独的协程来维护这两个通道。保证数据的一致性。
* @author: niuyufu
 */
//共享变量有一个读通道和一个写通道组成
type sharded_var struct {
	reader chan int
	writer chan int
}

//共享变量维护协程
func sharded_var_whachdog(v sharded_var) {
	go func() {
		//初始值
		var value int = 0
		for {
			//监听读写通道，完成服务
			select {
			case value = <-v.writer:
			case v.reader <- value:
			}
		}
	}()
}

//超时避免阻塞
func never_leak(ch chan int) {
	//初始化timeout,缓冲为1
	timeout := make(chan bool, 1)
	//启动timeout协程，由于缓存为1，不可能泄漏
	go func() {
		time.Sleep(1 * time.Second)
		timeout <- true
	}()
	//监听通道，由于设有超时，不可能泄漏
	select {
	case <-ch:
		// a read from ch has occurred
	case <-timeout:
		// the read from ch has timed out
	}
}

func main() {
	//初始化，并开始维护协程
	v := sharded_var{make(chan int), make(chan int)}
	sharded_var_whachdog(v)

	//读取初始化
	fmt.Println(<-v.reader)
	//写入一个值
	v.writer <- 1
	//读取新写入的值
	fmt.Println(<-v.reader)
}


golang之select之超时使用

package main

import (
	"fmt"
	"time"
)

/**
* select之超时使用
* select的使用，会随机从case中筛选可执行操作，如果没有能执行的操作则阻塞。
* 使用超时避免读阻塞，使用缓冲避免写阻塞
* @author: niuyufu
 */
func main() {
	timeout := make(chan bool, 1)
	ch := make(chan int)

	//每秒生产一下true数据
	go func() {
		time.Sleep(1e9) //sleep one second
		timeout <- true
	}()

	select {
	case <-ch:
		fmt.Println("ch pop")
	case <-timeout:
		fmt.Println("timeout!")
	}
}


golang之select之默认值操作

package main

import (
	"fmt"
)

/**
* select之默认值操作
* 没有能操作的case时，默认调用default操作
* @author: niuyufu
 */
func main() {
	ch1 := make(chan int, 1)
	ch2 := make(chan int, 1)

	//协程操作不仅能同步调用还能异步调用
	ch1 <- 1
	//同步
	select {
	case <-ch1:
		fmt.Println("ch1 pop one element")
	case <-ch2:
		fmt.Println("ch2 pop one element")
	default:
		fmt.Println("default")
	}
}


golang之select验证是否通道写满？

package main

import (
	"fmt"
)

/**
* select验证是否通道写满？
* @author: niuyufu
 */
func main() {
	ch1 := make(chan int, 1)
	ch1 <- 1
	select {
	case ch1 <- 2:
		fmt.Println("channel is not full !")
	default:
		fmt.Println("channel is full !")
	}
}


golang之生产者消费者

package main

import (
	"fmt"
	"time"
)

func main() {

	ch := make(chan int, 1)
	timeout := make(chan bool, 1)

	//生产者
	go func() {
		for i := 0; i < 5; i++ {
			ch <- i
			fmt.Println("生产了：%d", i)
		}
	}()

	//消费者
	var value int
	//设置最大操作数
	for i := 0; i < 10; i++ {
		//每秒生产一下true数据
		go func() {
			time.Sleep(10 * time.Microsecond) //sleep one second
			timeout <- true
		}()
		select {
		case value = <-ch:
			fmt.Println("消费了：%d", value)
		case <-timeout:
			fmt.Println("timeout!")
		}
	}
}


e421083458
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
golang并发编程的实现
09-18
主要介绍了golang并发编程的实现,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Golang实现Redis分布式锁解决秒杀问题
sunriseYJP的博客
08-07 845
登录是通过2个字段，一个是mobile，一个是password，生成了mobile从1到2000，密码默认是123456。我们使用有缓冲的通道和sync.WaitGroup信号量，来控制协程的数量在2000个以内。然后写一个单元测试，实现新注册的2000个用户登录，然后获取token。先写一个脚本sql，插入2000个用户。
Golang知识点四、并发编程
菜到不敢run
04-16 1390
Golang中的锁   Golang并发通过goroutine来实现。goroutine是由Go语言的运行时（runtime）调度完成的，而线程是由操作系统调度完成。goroutine和channel是Go秉承的CSP(Communicating Sequential Process)并发模式的重要实现基础。 1. 竞态   竞态是指在多个goroutine按某些交错顺序执行时，程序无法给出正确的结果。它对于程序是致命的，因为它们潜伏在程序中，出现的频率也很低，有可能仅在高负载环境或者在特定的编译器、平
go并发编程
止语的博客
03-19 491
介绍之前，先澄清下并发这个概念，并发指的是多个任务被（一个）cpu 轮流切换执行，在 Go 语言里面主要用 goroutine （协程）来实现并发，类似于其他语言中的线程。
Go语言并发详解
qq_41854911的博客
11-09 6867
文章目录一、Go语言并发简述（并发的优势）进程/线程并发/并行协程/线程Goroutine 介绍channel二、Go语言goroutine（轻量级线程）使用普通函数创建 goroutine1) 格式2) 例子使用匿名函数创建goroutine1) 使用匿名函数创建goroutine的格式2) 使用匿名函数创建goroutine的例子提示三、Go语言并发通信四、Go语言竞争状态简述Goroutine 7 (finished) created at: main.main() D:/code/src/m
golang并发编程实战
最新发布
03-08
golang并发编程实战，channel原理实现过程，最佳实践，goroutine原理和go并发的实战，从实际出发展开对go并发编程的说明和示例，充分说明go语言再并发编程的优势
ghostwwl#note#golang并发编程的两种限速方法1
07-25
实现实现逻辑如下：//LimitRate 限速type LimitRate struct {func (l *LimitRate) Limit() bool {
Go-解决Golang并发性练习
08-13
解决Golang并发性练习
go语言并发编程
weixin_51530404的博客
03-05 208
💨💨💨下面是go语言并发编程的学习笔记。
golang的并发编程
Destiny_shine的博客
07-26 2957
一、进程、线程、协程、并发、并行 1、进程、线程、协程 1.1 进程： 对操作系统来说，进程是资源分配的最小单位，程序启动时，操作系统就会给这个程序分配一块内存空间，对于程序本身而言它认为这是一整块连续的内存空间，称为虚拟内存空间，而实际上落实到操作系统内核时通常是一块块的内存碎片。一个进程大小可能是几个G，进程之间切换开销较大，进程可以实现操作系统的并发。 这片虚拟内存空间，可以划分为内核空间和用户空间，它们相互隔离，程序即使崩溃了，内核空间也不会受到影响。进程运行在内核空间时称为内核态，运行在用户空间
当Golang遇到高并发秒杀，世界开始变得简单
weixin_33907511的博客
06-12 2663
　　遇到GO语言也是偶尔的一次机会，工作上做架构相关的事情，对新发展比较火爆的语言肯定要关注下。就这样步入了GO语言的世界，GO给我带来了全新的体验;　　一直做一件事情的人往往会被一件事情所困，开始实践GO语言的时候总感觉哪哪都别扭，特别是把结构体当成类，还有结构体的继承，写面向对想多了开始还真扭不过来。不过写的多了渐渐地也习惯了，甚至感觉越来越顺眼。　　在熟悉了GO一段时间后，也停止了一会，脑子...
Go 并发编程
qq_46457076的博客
01-17 449
关于 Go 语言之高性能并发编程的基础知识！
Go语言并发编程（千锋教育）
qq_56517253的博客
08-03 810
千锋教育，Go语言最大的亮点：高并发，goroutine，channel！
Golang 并发编程指南
j简说Linux的博客
11-09 771
简单调度图如上，有关于 P 再多个 M 中切换，公共 goroutine 队列，M 从线程缓存中创建等步骤没有体现，复杂过程可以参考文章简单了解。我们可以再每个 CPU 上进行循环无关的迭代计算，我们仅需要创建完所有的 goroutine 后，从 channel 中读取结束信号进行计数即可。这东西可以并发读，不可以并发读写/并发写写，不过现在即便场景是读多写少也很少用到这，一般集群环境都得分布式锁了。关系如图，灰色的 G 则是暂时还未运行的，处于就绪态，等待被调度，这个队列被 P 维护。
Go并发编程详解
金戈鐡馬
12-04 1271
随着硬件的发展，并发程序变得越来越重要。Web服务器会一次处理成千上万的请求。平板电脑和手机app在渲染用户画面同时还会后台执行各种计算任务和网络请求。即使是传统的批处理问题--读取数据，计算，写输出--现在也会用并发来隐藏掉I/O的操作延迟以充分利用现代计算机设备的多个核心。计算机的性能每年都在以非线性的速度增长。
go 进阶 多路复用支持: 一. netpoller 初始化
qq_29799655的博客
05-06 645
首先golang在net/http下对多路复用进行了支持,提供了五个函数,针对不同平台进行了指定实现,例如linux环境下epoll封装的文件在src/runtime/netpoll_epoll.go中，windows环境下多路复用模型实现在src/runtime/netpoll_windows.go。
golang 协程和IO多路复用
qq_49723651的博客
11-30 2141
协程和IO多路复用 文章目录协程和IO多路复用IO阻塞问题阻塞式IO非阻塞式IOIO多路复用selectpollepoll IO阻塞问题 我们知道。通过操作系统记录的进程控制信息，可以找到打开文件描述符表。其中，打开的文件、创建的socket等等，都会记录到这张表里面。 socket的所有操作都由操作系统来提供，也就是要通过系统调用来完成。每创建一个socket，就会在打开文件描述符表中对应增加一条记录，而返回给应用程序的只有一个socket描述符，用于识别不同的socket。而且每个TCP s
golang学习笔记系列之并发编程
max_LLL的博客
10-05 833
同步是通道上发送和接收之间交互的基础。在上面的代码中，我们可以看到在主协程中调用了Gosched方法，因此当主协程和show_msg协程抢占处理机时，如果show_msg协程先抢到执行，则执行结果如上；在golang中，如果除了主协程以外还有其他的协程，当主协程结束的时候其他协程也会一起结束，不管它们有没有执行完毕，即默认是协程守护的。可以看到上面的代码的每次运行结果都可能不一样，因为每一个show_msg都用一个协程来启动，它们和主协程一样，但是只要主协程执行结束，不管它们有没有被执行，都会被结束。
golang 并发编程
11-15
Golang 是一种编程语言，其设计目标之一就是支持并发编程。在 Golang 中，我们可以使用 goroutine 来实现并发操作。goroutine 可以理解为一种轻量级的线程，它可以由 Go 语言的运行时环境进行调度，并发执行。 在 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

e421083458

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值