Go并发编程:发生死锁、活锁的案例分析

fatal error: all goroutines are asleep - deadlock! 使用golang中的channel的时候,有时候会出现如下的报错: fatal error: all goroutines are asleep - deadlock! 那么,引起该错误的原因是什么呢?报错中的信息提示我们,所有的goroutine都休眠了,也就是说没有goroutine在运行了,所以说,如果我们还在从channel中读取数据,但是没有其他的协程将数据放进channel中,那么我们读取了什么,根本就读不到! package main import ( "fmt" ) func ma 阅读详情

什么是死锁、活锁

什么是死锁:就是在并发程序中,两个或多个线程彼此等待对方完成操作,从而导致它们都被阻塞,并无限期地等待对方完成。这种情况下,程序会卡死,无法继续执行。

什么是活锁:就是程序一直在运行,但是无法取得进展。例如,在某些情况下,多个线程会争夺同一个资源,然后每个线程都会释放资源,以便其他线程可以使用它。但是,如果没有正确的同步,这些线程可能会同时尝试获取该资源,然后再次释放它。这可能导致线程在无限循环中运行,却无法取得进展。

发生死锁的案例分析

  1. 编写会发生死锁的代码:
package main

import (
 "fmt"
 "sync"
)

func main() {
 var mu sync.Mutex
 mu.Lock()
 defer mu.Unlock()

 wg := sync.WaitGroup{}
 wg.Add(1)
 go func() {
  fmt.Println("goroutine started")
  mu.Lock() // 在这里获取了锁
  fmt.Println("goroutine finished")
  mu.Unlock()
  wg.Done()
 }()

 wg.Wait()
}

运行和输出:

[root@workhost temp02]# go run main.go 
goroutine started
fatal error: all goroutines are asleep - deadlock! # 错误很明显了,告诉你死锁啦!

goroutine 1 [semacquire]:
sync.runtime_Semacquire(0xc000010030?)
        /usr/local/go/src/runtime/sema.go:62 +0x27
...
...

上面的代码,使用 sync.Mutex 实现了一个互斥锁。主 goroutine 获取了锁,并启动了一个新的 goroutine。新 goroutine 也尝试获取锁来执行其任务。但是,由于主 goroutine 没有释放锁,新 goroutine 将一直等待锁,导致死锁。

  1. 代码改造

在上面的代码中,可以通过将主 goroutine 中的 defer mu.Unlock() 移到 goroutine 函数中的 mu.Unlock() 后面来解决问题。这样,当 goroutine 获取到锁后,它可以在完成任务后释放锁,以便主 goroutine 可以继续执行。

改造后的代码:

package main

import (
 "fmt"
 "sync"
)

func main() {
 var mu sync.Mutex
 mu.Lock()
 wg := sync.WaitGroup{}
 wg.Add(1)
 go func() {
  fmt.Println("goroutine started")
  mu.Lock() // 在这里获取了锁
  fmt.Println("goroutine finished")
  mu.Unlock()
  wg.Done()
 }()
 mu.Unlock() // 释放锁
 wg.Wait()
}

运行和输出:

[root@workhost temp02]# go run main.go 
goroutine started
goroutine finished
  1. 如何避免死锁

在 Go 语言中,要避免死锁,一定要清楚以下几个规则:

  • 避免嵌套锁:在使用多个锁时,确保它们的嵌套顺序相同。否则,可能会出现循环等待的情况,导致死锁。
  • 避免无限等待:如果在获取锁时指定了超时时间,确保在超时后能够处理错误或执行其他操作。
  • 避免过度竞争:如果多个协程需要访问相同的资源,请确保它们不会互相干扰。可以使用互斥锁或读写锁等机制来解决竞争问题。
  • 使用通道:Go 语言中的通道可以用于协调并发操作。使用通道来传递消息和同步操作,可以避免死锁和竞争问题。
  • 确保资源释放:在使用锁或其他资源时,一定要确保它们在使用后得到释放,否则可能会导致死锁。
  • 使用 select 语句:在使用通道进行并发操作时,可以使用 select 语句来避免死锁。通过 select 语句选择多个通道中的一个进行操作,可以避免在某个通道被阻塞时出现死锁。

发生活锁的案例分析

  1. 编写会发生活锁的代码:
package main

import (
 "fmt"
 "sync"
)

func main() {
 var wg sync.WaitGroup
 var mu sync.Mutex
 var flag bool

 wg.Add(2)

 // goroutine 1
 go func() {
  // 先获取锁资源
  fmt.Println("goroutine 1 获取 mu")
  mu.Lock()
  defer mu.Unlock()

  // 然后等待 flag 变量的值变为 true
  fmt.Println("goroutine 1 等待标志")
  for !flag {
   // 不断循环等待
  }

  // 最终输出并释放锁资源
  fmt.Println("goroutine 1 从等待中释放")
  wg.Done()
 }()

 // goroutine 2
 go func() {
  // 先获取锁资源
  fmt.Println("goroutine 2 获取 mu")
  mu.Lock()
  defer mu.Unlock()

  // 然后等待 flag 变量的值变为 true
  fmt.Println("GoRoutine2 等待标志")
  for !flag {
   // 不断循环等待
  }

  // 最终输出并释放锁资源
  fmt.Println("GoRoutine 2 从等待中释放")
  wg.Done()
 }()

 // 在主线程中等待 1 秒钟,以便两个 goroutine 开始等待 flag 变量的值
 // 然后将 flag 变量设置为 true
 // 由于两个 goroutine 会同时唤醒并尝试获取锁资源,它们会相互等待
 // 最终导致了活锁问题,它们都无法向前推进
 fmt.Println("主线程休眠 1 秒")
 fmt.Println("两个goroutine都应该等待标志")
 flag = true
 wg.Wait()

 fmt.Println("所有 GoRoutines 已完成")
}

运行和输出:

[root@workhost temp02]# go run main.go 
主线程休眠 1 秒
两个goroutine都应该等待标志
goroutine 2 获取 mu
GoRoutine2 等待标志
GoRoutine 2 从等待中释放
goroutine 1 获取 mu
goroutine 1 等待标志
goroutine 1 从等待中释放
所有 GoRoutines 已完成

上面的代码存在活锁问题。如果两个goroutine同时等待flag变为true并且都已经获取了锁资源,那么它们就会进入一个死循环并相互等待,无法继续向前推进。

  1. 代码改造

改造后的代码:

package main

import (
 "fmt"
 "runtime"
 "sync"
)

func main() {
 var wg sync.WaitGroup
 var mu sync.Mutex
 var flag bool

 wg.Add(2)

 // goroutine 1
 go func() {
  // 先获取锁资源
  fmt.Println("goroutine 1 获取 mu")
  mu.Lock()
  defer mu.Unlock()

  // 然后等待 flag 变量的值变为 true
  fmt.Println("goroutine 1 等待标志")
  for !flag {
   runtime.Gosched() // 让出时间片
  }

  // 最终输出并释放锁资源
  fmt.Println("goroutine 1 从等待中释放")
  wg.Done()
 }()

 // goroutine 2
 go func() {
  // 先获取锁资源
  fmt.Println("goroutine 2 获取 mu")
  mu.Lock()
  defer mu.Unlock()

  // 然后等待 flag 变量的值变为 true
  fmt.Println("GoRoutine2 等待标志")
  for !flag {
   runtime.Gosched() // 让出时间片
  }

  // 最终输出并释放锁资源
  fmt.Println("GoRoutine 2 从等待中释放")
  wg.Done()
 }()

 // 在主线程中等待 1 秒钟,以便两个 goroutine 开始等待 flag 变量的值
 // 然后将 flag 变量设置为 true
 // 由于两个 goroutine 会同时唤醒并尝试获取锁资源,它们会相互等待
 // 最终导致了活锁问题,它们都无法向前推进
 fmt.Println("主线程休眠 1 秒")
 fmt.Println("两个goroutine都应该等待标志")
 flag = true
 wg.Wait()

 fmt.Println("所有 GoRoutines 已完成")
}

改造后的代码在等待flag变量的循环中加入了让出时间片的函数 runtime.Gosched(),这样两个goroutine在等待期间可以放弃时间片,以便其他goroutine可以执行并获得锁资源。这种方式可以有效地减少竞争程度,从而避免了活锁问题。

  1. 如何避免发生活锁的可能性

在 Go 语言的并发编程中,避免活锁的关键是正确地实现同步机制。以下是一些避免活锁的方法:

  • 避免忙等待:使用 sync.Cond 或者 channel 等同步机制来实现等待。这样避免了线程一直占用 CPU 资源而无法取得进展的问题。
  • 避免死锁:死锁往往是活锁的前提,因此正确地使用锁和同步机制可以避免死锁,从而避免活锁。
  • 减少锁的粒度:尽可能将锁的粒度缩小到最小范围,避免锁住不必要的代码块。
  • 采用超时机制:使用 sync.Mutex 的 TryLock() 方法或者使用 select 语句实现等待超时机制,这样可以防止线程无限期等待。
  • 合理设计并发模型:合理设计并发模型可以避免竞争和饥饿等问题,进而避免活锁的发生。

本文转载于WX公众号:不背锅运维(喜欢的盆友关注我们):https://mp.weixin.qq.com/s/gylcUAOWUkoB7zlve1mAoA

go语言day09 通道 协程的死锁 通道是在协程之间传输数据的。通道只存在单协程中调用肯定发生死锁,因为他不能在从入口传输的过程中 又去出口接收值。这项工作至少要两个协程完成。只有通道的入口或者出口也会死锁。只有入口协程会等一个出口放值;只有出口协程会等待入口传值。 阅读详情

相关推荐

GO语言基础教程(155)Go活锁:Go语言中的活锁:你的代码在跳舞,却从未前进?

在Go语言的并发世界里,死锁(Deadlock)常常被人们津津乐道,但它的"亲戚"——活锁(Livelock)却往往被忽视,尽管它的危害同样巨大。今天,我们就来深入剖析这个看似忙碌实则无效的并发陷阱。

jxf_jxfcsdn的博客 574

26. Go 语言中通道死锁经典错误案例详解

Hi,大家好,我是明哥。 在自己学习 Golang 的这段时间里,我写了详细的学习笔记放在我的个人微信公众号 《Go编程时光》,对于 Go 语言,我也算是个初学者,因此写的东西应该会比较适合刚接触的同学,如果你也是刚学习 Go 语言,不防关注一下,一起学习,一起成长。 我的在线博客:http://golang.iswbm.com 我的 Github:github.com/iswbm/GolangCodingTime 刚接触 Go 语言的信道的时候,经常会遇到死锁的错误,而导致这个错误的原因有很多种,这

王炳明 1036

Golang Mutex死锁检测与调试技巧

在Golang的并发编程中,Mutex(互斥锁)是一种常用的同步原语,用于保护共享资源,防止多个协程同时访问而导致数据竞争。然而,不正确地使用Mutex可能会导致死锁问题,即两个或多个协程相互等待对方释放锁,从而使程序陷入无限等待状态。本文的目的是深入探讨Golang中Mutex死锁的检测与调试技巧,帮助开发者识别、定位和解决死锁问题。范围涵盖了Mutex的基本概念、死锁的产生原因、常见的检测方法以及有效的调试技巧。本文将按照以下结构进行组织:首先介绍Mutex的核心概念和相关联系,包括其原理和架构;

AI Agent Harness Engineering 1224

fatal error: all goroutines are asleep - deadlock

由fatal error: all goroutines are asleep - deadlock ,引出 实际项目中goroutine+channel+select的使用总结

做一个有情怀的技术人 9805

STM32CubeMX最新版下载安装全攻略(附官网访问问题解决方案)

本文提供了STM32CubeMX最新版的详细下载与安装指南,并针对国内开发者常见的官网访问缓慢、注册验证邮件延迟等问题,给出了实用的解决方案和备选策略。通过清晰的步骤解析,帮助用户快速部署这一强大的STM32图形化配置工具,从而高效启动嵌入式开发项目。

weixin_28256233的博客 197

Unity接入Google登录:Credential Manager完整集成指南与避坑实践

在移动应用开发中,第三方登录是提升用户体验和降低注册门槛的关键技术。其核心原理是通过OAuth 2.0等授权协议,安全地获取用户在平台的身份凭证。对于面向海外市场的Unity应用,Google登录因其庞大的用户基数成为首选方案。然而,随着Android系统更新和隐私政策收紧,传统的WebView登录方式面临兼容性挑战。Credential Manager作为Google推出的现代化凭据管理API,通过系统级集成解决了这一问题,它统一了密码、通行密钥和第三方登录的调用接口,显著提升了登录成功率和原生体验。在U

weixin_28025327的博客 321

Go语言并发编程:死锁预防的性能优化之旅

首先介绍Go并发的基础,然后深入分析死锁的原因和识别方法。我们提供了有效的死锁预防技巧,包括使用Go标准库和第三方工具。通过分析Gin框架的案例,揭示了实际应用中的最佳实践。此外,还探讨了资源排序、银行家算法等高级算法。无论是新手还是经验丰富的开发者,本文都能为您的Go并发编程之旅提供丰富的见解和指导。

walkskyer的博客 2358

Aurix TC387 Ethernet代码解析之二_移植

英飞凌官方仅提供了TC397的例程,故需通过TC397例程来移植到TC387新建工程里。TC397官方例程名称【Ethernet_1_KIT_TC397_TFT】,网络上可以免费获取到,此处不赘述。使用工具【

m0_69929716的博客 886

Go 并发编程的『三座大山』:从临床研究系统看死锁、活锁与饥饿

在临床研究这个不容有失的领域,构建稳定、可靠的并发系统,是我作为架构师的核心职责。简化共享,明确边界:尽可能减少 Goroutine 之间共享的内存。多用 Channel 通信,少用共享内存加锁。数据的唯一所有者应该清晰明确。建立秩序,统一路径:当必须使用多把锁时,为资源建立全局唯一的加锁顺序,并严格遵守。这是规避死锁的银弹。拥抱随机,打破僵局:在分布式或并发重试场景,引入随机退避策略,避免系统陷入同步的、无进展的活锁状态。追求公平,防止独占。

张国良的博客 939

IEEE Transactions模板中参考文献作者缩写、期刊名缩写

本文章记录如何在IEEE Transactions的模板中,解决参考文献的作者缩写、期刊名字缩写的问题。

weixin_43981621的博客 1万+

别再死记公式了!用TL072运放设计带通滤波器,调出干净正弦波的实战心得与误区盘点

本文分享了使用TL072运放设计带通滤波器的实战经验,重点解决波形失真问题,提供单电源供电优化、动态调谐技巧及仿真与现实的参数修正方法,帮助工程师调出纯净正弦波。内容涵盖模拟电路设计中的常见误区与解决方案,适合电子工程师和爱好者参考。

weixin_29172963的博客 409

深入剖析并发编程中的活锁(Livelock):概念、成因、诊断与解决方案

在并发编程的世界里,开发者们通常对死锁(Deadlock)​​ 耳熟能详——两个或多个线程无限期地互相等待对方持有的资源,导致所有线程都陷入停滞,整个系统无法继续推进。然而,死锁并非并发协调失误的唯一形式。还有一种更为隐蔽和“礼貌”的问题,线程们并非陷入静止的等待,而是在“忙碌地空转”,看似在工作,实则没有任何进展。这种现象就是活锁(Livelock)​。

一起探索IT的世界 1034

Codex 100个真实案例 - 用AI做股票K线分析工具(技术指标全自动)

本案例将用 Codex 从零搭建一个完整的股票 K 线分析工具。通过自然语言驱动,我们让 AI 自动完成股票数据获取(akshare)、K 线图绘制(mplfinance + ECharts)、技术指标计算(MA/EMA/MACD/RSI/KDJ/布林带)、买卖信号提示(金叉/死叉、超买超卖)、多股对比分析、Web 可视化界面(Flask + ECharts)、PDF 报告生成以及定时监控邮件推送等全套功能。全程用自然语言指令驱动 Codex,零手写代码实现专业级量化分析平台!

yueyeguzhuo的专栏 879

golang mysql 死锁_Go语言死锁、活锁和饥饿概述

typevaluestruct{musync.Mutexvalueint}varwgsync.WaitGroupprintSum:=func(v1,v2*value){deferwg.Done()v1.mu.Lock()//在这里,我们尝试进入临界区来传入一个值。deferv1.mu.Unlock()//在这里,我们使用defer语句在printSum返回之前退出临界区。time.Sleep(2*...

weixin_33982355的博客 319

后仿真中《SDF反标必懂连载篇》之 <INTERCONNECT/IOPATH> 到底反标电路路径是哪里

对于SDF INTERCONNECT ENTRY 描述,我们在之前的文章有详解。读万卷书,行万里路。实践很重要。今天,搞一下SDF INTERCONNECT / IOPATH 延迟数据信息,究竟反标的是哪一路径延时?究竟在电路上一段段如何表现出延迟现象的呢?

那么菜的博客 2139

11.嵌入式控制器EC实战 KBC矩阵键盘Keyboard开发流程

文章目录笔记本矩阵键盘概述矩阵键盘的扫描方式行列扫描方式逐行逐列扫描方式EC中矩阵键盘是如何扫描并得到码值的(代码分析) 笔记本矩阵键盘概述 在EC中支持两种形式的键盘,一种是PS/2接口的键盘,这种键盘几乎已经被USB接口的键盘所取代,所以PS/2接口的键盘不在我们的讨论范围。 另一种键盘则是矩阵键盘,也是笔记本电脑的内置键盘,该键盘类似于学习单片机时使用的4*4的那种键盘,笔记本使用的矩阵键盘有三种规格,分别是16*8、17*8和18*8。16、17和18代表着该款键盘的列数,8代表着键盘的行数,我们这

qq_30135687的博客 3811

Go语言并发之道学习-----死锁,活锁和饥饿

死锁和活锁 死锁:会使得所有并发程序在等待,如果没有外界干预,程序不能恢复 type values struct{ mu sync.Mutex value int } func TestMutes(v1, v2 *values){ defer wg.Done() v1.mu.Lock() defer v1.mu.Unlock() time.Sleep(2*time.Second) v...

alvin_666的博客 1009

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

mysql 活锁_Go语言死锁、活锁和饥饿概述

本节我们来介绍一下死锁、活锁和饥饿这三个概念。死锁死锁是指两个或两个以上的进程(或线程)在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。死锁发生的条件有如下几种:1) 互斥条件线程对资源的访问是排他性的,如果一个线程对占用了某资源,那么其他线程必须处于等待状态,直到该资源被释放。2...

weixin_39922642的博客 304

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

Go语言死锁、活锁和解锁概述

本节我们来介绍一下死锁、活锁和解锁这三个概念 死锁 死锁是指两个或者两个以上的进程(或线程)在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,他们讲无法推进下去。此时称系统处于死锁状态或者产生死锁,这些永远在互相等待的进程死锁进程。 死锁发生的条件有如下几种: 1)互斥条件 线程对资源的访问是排他性的,如果一个线程对占用某个资源,那么其他线程处于等待状态,直到该资源...

zuiyijiangnan的博客 869

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Go语言死锁、活锁和饥饿概述

本节我们来介绍一下死锁、活锁和饥饿这三个概念。 死锁 死锁是指两个或两个以上的进程(或线程)在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。 死锁发生的条件有如下几种: 1) 互斥条件 线程对资源的访问是排他性的,如果一个线程对占用了某资源,那么其他线程必须处于等待状态,直到该资源被释放。 2) 请求和保持条件 线程 T1 至少已经保持了一个资源 R1 占用,但又提出使用另一个

xyz的专栏 448

Golang 锁和条件变量

前言 前面我们为了解决go程同步的问题我们使用了channel, 但是go也提供了传统的同步工具. 它们都在go的标准库代码包 sync 和 sync/atomic 中. 下面我们来看一下锁的应用. 什么是锁呢? 就是某个协程(线程)在访问某个资源时先锁住, 防止其他协程的访问, 等访问完毕解锁后其他协程再来加锁进行访问. 这和我们生活中加锁使用公共资源相似, 例如: 公共卫生间. 死锁 死锁是指两个或者两个以上的进程在执行过程中, 由于竞争资源或者由于彼此通信而造成的一种阻塞的现象, 若无外力作用, 它们

李培冠的博客 1万+

多线程与并发编程常见问题深度解析(死锁、活锁、饥饿全收录)

深入解析多线程与并发编程常见问题,涵盖死锁、活锁、饥饿的成因与解决方案,适用于高并发场景下的性能优化。通过同步机制、资源调度策略提升程序稳定性,开发者必备指南,值得收藏。

PixelIsle的博客 909

如何用pprof检测golang代码中的死锁

用golang做的后端项目,为了实现高性能,通常会在运行过程中开启多个goroutine,并行处理并发请求。 并发处理请求提升效率的同时,也引入了资源并发读写的场景,这通常会带来一些问题,比如同时读写一个map会导致程序panic,为此,我们需要为那些不应被多个goroutine同时访问的资源加锁。 一个复杂的后端项目,通常会包含很多很多的锁,我们很难保证我们写的程序不出现死锁,或者长时间的锁等待。锁的问题不像业务逻辑的问题那么容易被发现,它有时可能只是阻塞了某个goroutine,这种情况下整体的功能

djqueen的博客 1万+

golang项目 如何排查死锁

之前写过一篇如何用pprof检测golang代码中的死锁,讲了下如何发现代码中的死锁,发现了死锁怎么办?自然是要解之。。最近刚好解决了两个死锁,分享一下心得,希望能帮助到大家~ 我把死锁分为两种,一种为简单死锁,另一种为并发场景下的死锁,接下来我们分别来说一说。 简单死锁 所谓简单死锁,就是写代码的时候粗心大意写出来的,比如说我们写了一个这样的函数: 函数A会在获取锁之后调用函数B,而B也要获取这个锁,这时候显然就会发生死锁,而且是百分百出现的。 现在你看着我的这个图可能觉得,我怎么可能犯如此

djqueen的博客 6431

理理并发:死锁,活锁与饥饿

一、并发问题的产生 若多个cpu需要对同一内存地址中的数据,进行增删改查,必须按先来后到的顺序进行。保证不了顺序,程序就会出现问题。这就是所谓的竞争条件 race condition 二、并发问题的场景 先跑个程序看看: func main() { runtime.GOMAXPROCS(1) // P的值 var data = 0 access := func(i int) { ...

erlang_boy 333
上一篇: PrometheusOperator云原生监控:基于operator部署的资源内部链路分析
下一篇: 值得收藏:K8S的kubectl常用命令已经按场景分好类,请您查阅。
不背锅运维
博客等级 码龄4年 38粉丝 1原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值