掌握Golang中的数据竞争检测:runtime/race包全面教程

掌握Golang中的数据竞争检测:runtime/race包全面教程

    • 引言
    • 数据竞争问题概述
      • 数据竞争的定义
      • 数据竞争对程序的影响
      • 常见数据竞争场景
    • Golang `runtime/race`包概述
      • `runtime/race`包简介
      • 启用数据竞争检测
        • 使用 `go run`
        • 使用 `go build`
        • 使用 `go test`
    • 基本用法与示例
      • 单元测试中的使用
        • 示例代码
        • 运行测试
      • 命令行中的使用
        • 使用 `go run`
        • 使用 `go build`
    • 第4章 深入理解`runtime/race`包
      • 工作原理
      • `race`检测的局限性
    • 实战案例
      • 案例一:简单数据竞争检测
        • 问题描述
        • 示例代码
        • 使用`race`包检测数据竞争
        • 解决方案与最佳实践
      • 案例二:复杂数据结构中的数据竞争
        • 问题描述
        • 示例代码
        • 使用`race`包检测数据竞争
        • 解决方案与最佳实践
    • 提高数据竞争检测效率
      • 优化代码结构
        • 示例代码
      • 使用锁和通道
        • 使用锁(mutex)
        • 使用通道(channel)
    • 常见问题与解决方案
      • 常见错误及其修复
        • 示例一:未同步的共享变量访问
        • 示例二:未同步的读写操作
      • 处理误报
    • 进阶技巧
      • 高级数据竞争检测
        • 使用条件变量
        • 使用读写锁
      • `race`包与其他工具的结合
        • 将`race`包与静态分析工具结合使用
        • 使用并发测试工具
    • 结论

在这里插入图片描述

引言

在现代软件开发中,随着多核处理器的普及并发编程已经变得越来越重要。然而,并发编程也带来了新的挑战,其中最常见的问题之一就是数据竞争(data race)。数据竞争是指两个或多个并发执行的线程访问同一个共享变量,并且至少有一个线程对该变量进行了写操作,这种情况会导致不可预知的程序行为,严重时可能会导致程序崩溃或数据不一致。

为了帮助开发者检测和解决数据竞争问题,Golang 提供了一个强大的工具包——runtime/raceruntime/race包是Golang标准库中的一部分,旨在检测并发程序中的数据竞争问题。它通过在编译和运行时插入额外的检测代码,帮助开发者快速发现和修复数据竞争问题,从而提高程序的稳定性和可靠性。

在本教程中,我们将深入探讨runtime/race包的使用方法与技巧。通过丰富的代码示例和详细的解释,我们将一步步教你如何在实际开发中利用runtime/race包检测和解决数据竞争问题。无论你是正在编写多线程程序还是处理复杂并发数据结构,本教程都将为你提供实用的指导和最佳实践。

接下来,我们将从数据竞争问题的概述开始,逐步深入了解runtime/race包的基本用法、工作原理、实战案例以及高级技巧,帮助你全面掌握这一工具的使用。

数据竞争问题概述

数据竞争的定义

数据竞争是指在并发程序中,两个或多个线程在没有适当同步的情况下同时访问同一个共享变量,并且至少有一个线程对该变量进行了写操作。由于访问顺序的不确定性,这种情况会导致不可预知的程序行为,难以调试和修复。

package mainimport ("fmt""sync"
)var counter intfunc increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {counter++}
}func main() {var wg sync.WaitGroupwg.Add(2)go increment(&wg)go increment(&wg)wg.Wait()fmt.Println("Final Counter:", counter)
}

在上述示例中,两个goroutine同时对共享变量counter进行递增操作,因为没有适当的同步机制,这会导致数据竞争,counter的最终值可能并不是预期的2000。

数据竞争对程序的影响

数据竞争问题对程序有多方面的影响,包括但不限于:

  1. 性能问题:由于不同线程对共享资源的争用,数据竞争会导致程序性能下降,甚至出现死锁等问题。
  2. 数据不一致性:未正确同步的数据访问会导致数据的不一致性,进而导致逻辑错误。
  3. 程序崩溃:严重的数据竞争问题可能会导致程序崩溃,尤其是在并发环境下的非法内存访问。

常见数据竞争场景

一些常见的数据竞争场景包括:

  1. 并发写操作:多个goroutine同时写入同一个共享变量。
  2. 读写操作:一个goroutine读取变量的同时,另一个goroutine写入该变量。
  3. 未同步的共享资源访问:缺乏适当的锁机制或同步原语,导致多个线程同时访问共享资源。

了解了数据竞争的定义和影响后,我们将深入探讨Golang提供的解决方案——runtime/race包,看看它是如何帮助我们检测和解决这些问题的。

Golang runtime/race包概述

runtime/race包简介

runtime/race包是Golang标准库中的一个重要组成部分,用于检测并发程序中的数据竞争问题。它通过在编译和运行时插入额外的检测代码,帮助开发者快速发现并修复数据竞争问题,从而提高程序的稳定性和可靠性。

与其他手动检测方法不同,runtime/race包能够自动检测并报告数据竞争问题,这大大减少了开发者手动查找和调试的工作量。

启用数据竞争检测

要在Golang中启用数据竞争检测,只需在编译时添加-race标志。以下是几个常见的使用方法:

使用 go run

通过 go run 命令直接运行程序并启用数据竞争检测:

go run -race main.go
使用 go build

通过 go build 命令编译程序,并启用数据竞争检测:

go build -race -o myprogram main.go
./myprogram
使用 go test

在运行测试时启用数据竞争检测:

go test -race ./...

下面是一个启用了数据竞争检测的示例代码:

package mainimport ("fmt""sync"
)var counter intfunc increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {counter++}
}func main() {var wg sync.WaitGroupwg.Add(2)go increment(&wg)go increment(&wg)wg.Wait()fmt.Println("Final Counter:", counter)
}

通过上述方式运行代码,如果存在数据竞争问题,程序会输出相关的检测信息,帮助开发者定位问题。

在下一章中,我们将详细介绍runtime/race包的基本用法和具体示例,帮助你更好地理解和使用这一工具。

基本用法与示例

在这一章中,我们将深入介绍runtime/race包的基本用法,并通过具体示例来展示如何在实际开发中使用该包进行数据竞争检测。

单元测试中的使用

在开发过程中,单元测试是检测数据竞争问题的一个重要环节。通过在单元测试中启用race检测,可以更早地发现并解决并发问题。

示例代码

以下是一个简单的单元测试示例,展示了如何在测试中启用race检测:

package mainimport ("sync""testing"
)var counter intfunc increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {counter++}
}func TestIncrement(t *testing.T) {var wg sync.WaitGroupwg.Add(2)go increment(&wg)go increment(&wg)wg.Wait()if counter != 2000 {t.Errorf("Expected counter to be 2000, but got %d", counter)}
}
运行测试

使用以下命令运行测试并启用数据竞争检测:

go test -race ./...

如果存在数据竞争问题,go test 命令会输出相关的检测信息。例如:

==================
WARNING: DATA RACE
Write at 0x00c0000a0010 by goroutine 8:main.increment()/path/to/your/code/main.go:12 +0x3cPrevious read at 0x00c0000a0010 by goroutine 7:main.TestIncrement()/path/to/your/code/main_test.go:19 +0x68
==================

通过这种方式,可以在测试阶段及早发现并解决数据竞争问题。

命令行中的使用

除了在单元测试中启用race检测外,我们还可以在命令行中使用go rungo build命令启用数据竞争检测。

使用 go run

使用 go run 命令直接运行程序并启用数据竞争检测:

go run -race main.go
使用 go build

使用 go build 命令编译程序,并启用数据竞争检测:

go build -race -o myprogram main.go
./myprogram

以下是一个示例代码,展示了如何在命令行中启用race检测:

package mainimport ("fmt""sync"
)var counter intfunc increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {counter++}
}func main() {var wg sync.WaitGroupwg.Add(2)go increment(&wg)go increment(&wg)wg.Wait()fmt.Println("Final Counter:", counter)
}

通过上述方式运行代码,如果存在数据竞争问题,程序会输出相关的检测信息。例如:

==================
WARNING: DATA RACE
Write at 0x00c0000a0010 by goroutine 8:main.increment()/path/to/your/code/main.go:12 +0x3cPrevious read at 0x00c0000a0010 by goroutine 7:main.main()/path/to/your/code/main.go:18 +0x68
==================

通过在命令行中启用race检测,可以方便地在开发过程中检测数据竞争问题,提高代码质量。


第4章 深入理解runtime/race

在这一章中,我们将深入探讨runtime/race包的工作原理及其局限性,帮助你更好地理解这一工具的内部机制。

工作原理

runtime/race包通过在编译时插入额外的检测代码,监控程序中所有共享变量的访问情况。在运行时,这些检测代码会记录每个goroutine对共享变量的读写操作,并检查是否存在未同步的并发访问。

具体来说,runtime/race包的工作机制包括以下几个步骤:

  1. 编译时插入检测代码:在编译阶段,Golang编译器会在每个变量访问的地方插入检测代码。这些代码用于记录当前goroutine的ID、访问的内存地址以及操作类型(读或写)。
  2. 运行时监控访问情况:在运行时,插入的检测代码会记录所有goroutine对共享变量的读写操作,并维护一个访问历史表。当一个goroutine访问某个变量时,runtime/race包会检查是否存在其他未同步的并发访问。
  3. 检测数据竞争:如果检测到未同步的并发访问,runtime/race包会报告数据竞争问题,输出详细的检测信息,包括变量的内存地址、访问的goroutine以及具体的代码位置。

race检测的局限性

虽然runtime/race包是一个强大的工具,但它也有一定的局限性:

  1. 性能开销:由于插入了额外的检测代码,启用race检测会增加程序的运行时间和内存开销。在某些性能敏感的应用中,这可能会影响程序的正常运行。
  2. 误报与漏报:尽管runtime/race包能够检测大部分数据竞争问题,但它并不能保证100%的准确性。在某些情况下,可能会出现误报或漏报,尤其是涉及复杂数据结构和高级同步原语时。
  3. 仅支持Go语言runtime/race包是Golang标准库的一部分,仅支持Go语言的程序。如果你的项目涉及其他编程语言,需要使用其他工具来检测数据竞争问题。

了解了runtime/race包的工作原理及其局限性后,我们将通过几个实际案例,展示如何在实际开发中使用这一工具检测和解决数据竞争问题。

实战案例

在这一章中,我们将通过几个具体的实战案例,展示如何使用runtime/race包检测和解决数据竞争问题。每个案例都包括问题描述、检测过程和解决方案。

案例一:简单数据竞争检测

问题描述

假设我们有一个简单的计数器程序,多个goroutine同时对计数器进行递增操作,但没有使用任何同步机制。我们希望检测并解决该程序中的数据竞争问题。

示例代码
package mainimport ("fmt""sync"
)var counter intfunc increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {counter++}
}func main() {var wg sync.WaitGroupwg.Add(2)go increment(&wg)go increment(&wg)wg.Wait()fmt.Println("Final Counter:", counter)
}
使用race包检测数据竞争

使用以下命令启用数据竞争检测并运行程序:

go run -race main.go

如果存在数据竞争问题,程序会输出相关的检测信息:

==================
WARNING: DATA RACE
Write at 0x00c0000a0010 by goroutine 8:main.increment()/path/to/your/code/main.go:12 +0x3cPrevious read at 0x00c0000a0010 by goroutine 7:main.main()/path/to/your/code/main.go:18 +0x68
==================
解决方案与最佳实践

为了避免数据竞争问题,我们可以使用互斥锁(mutex)来保护共享变量的访问。以下是修复后的代码:

package mainimport ("fmt""sync"
)var counter int
var mu sync.Mutexfunc increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {mu.Lock()counter++mu.Unlock()}
}func main() {var wg sync.WaitGroupwg.Add(2)go increment(&wg)go increment(&wg)wg.Wait()fmt.Println("Final Counter:", counter)
}

通过在对共享变量进行操作时使用mu.Lock()mu.Unlock(),我们可以确保每次只有一个goroutine访问counter,从而避免数据竞争问题。

案例二:复杂数据结构中的数据竞争

问题描述

假设我们有一个并发访问的共享列表,多个goroutine同时对列表进行读写操作,但没有使用任何同步机制。我们希望检测并解决该程序中的数据竞争问题。

示例代码
package mainimport ("fmt""sync"
)var list []intfunc addToList(value int, wg *sync.WaitGroup) {defer wg.Done()list = append(list, value)
}func main() {var wg sync.WaitGroupwg.Add(2)go addToList(1, &wg)goaddToList(2, &wg)wg.Wait()fmt.Println("Final List:", list)
}
使用race包检测数据竞争

使用以下命令启用数据竞争检测并运行程序:

go run -race main.go

如果存在数据竞争问题,程序会输出相关的检测信息:

==================
WARNING: DATA RACE
Write at 0x00c0000a0010 by goroutine 8:main.addToList()/path/to/your/code/main.go:12 +0x3cPrevious read at 0x00c0000a0010 by goroutine 7:main.main()/path/to/your/code/main.go:18 +0x68
==================
解决方案与最佳实践

为了避免数据竞争问题,我们可以使用互斥锁(mutex)来保护共享列表的访问。以下是修复后的代码:

package mainimport ("fmt""sync"
)var list []int
var mu sync.Mutexfunc addToList(value int, wg *sync.WaitGroup) {defer wg.Done()mu.Lock()list = append(list, value)mu.Unlock()
}func main() {var wg sync.WaitGroupwg.Add(2)go addToList(1, &wg)go addToList(2, &wg)wg.Wait()fmt.Println("Final List:", list)
}

通过在对共享列表进行操作时使用mu.Lock()mu.Unlock(),我们可以确保每次只有一个goroutine访问列表,从而避免数据竞争问题。

提高数据竞争检测效率

在这一章中,我们将探讨如何通过优化代码结构、使用锁和通道等方式,提高数据竞争检测的效率。

优化代码结构

优化代码结构可以减少数据竞争问题的发生,从根本上提高程序的并发性能。以下是一些常见的优化策略:

  1. 减少共享变量的使用:尽量减少共享变量的数量,减少并发访问的机会。
  2. 局部变量优先:尽量使用局部变量代替全局变量,避免多个goroutine访问同一个变量。
  3. 分片处理:将大任务分解为多个小任务,每个任务在独立的goroutine中执行,减少共享资源的竞争。
示例代码

以下是一个优化后的示例代码,通过减少共享变量的使用,避免数据竞争问题:

package mainimport ("fmt""sync"
)func increment(wg *sync.WaitGroup, counter *int) {defer wg.Done()for i := 0; i < 1000; i++ {*counter++}
}func main() {var wg sync.WaitGroupvar counter intwg.Add(2)go increment(&wg, &counter)go increment(&wg, &counter)wg.Wait()fmt.Println("Final Counter:", counter)
}

使用锁和通道

使用互斥锁(mutex)和通道(channel)是避免数据竞争问题的常用方法。互斥锁可以确保每次只有一个goroutine访问共享变量,而通道则可以用于在goroutine之间传递数据,避免直接访问共享变量。

使用锁(mutex)

以下是一个使用互斥锁(mutex)避免数据竞争问题的示例代码:

package mainimport ("fmt""sync"
)var counter int
var mu sync.Mutexfunc increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {mu.Lock()counter++mu.Unlock()}
}func main() {var wg sync.WaitGroupwg.Add(2)go increment(&wg)go increment(&wg)wg.Wait()fmt.Println("Final Counter:", counter)
}
使用通道(channel)

以下是一个使用通道(channel)避免数据竞争问题的示例代码:

package mainimport ("fmt"
)func increment(c chan int, done chan bool) {counter := 0for i := 0; i < 1000; i++ {counter++}c <- counterdone <- true
}func main() {c := make(chan int, 2)done := make(chan bool, 2)go increment(c, done)go increment(c, done)<-done<-donecounter := <-c + <-cfmt.Println("Final Counter:", counter)
}

通过将计数操作放在通道中,我们可以避免直接访问共享变量,从而避免数据竞争问题。

常见问题与解决方案

在这一章中,我们将探讨一些常见的数据竞争问题及其解决方案,帮助你在实际开发中更好地使用runtime/race包。

常见错误及其修复

示例一:未同步的共享变量访问

未同步的共享变量访问是最常见的数据竞争问题之一。以下是一个示例代码:

package mainimport ("fmt""sync"
)var counter intfunc increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {counter++}
}func main() {var wg sync.WaitGroupwg.Add(2)go increment(&wg)go increment(&wg)wg.Wait()fmt.Println("Final Counter:", counter)
}

解决方案:使用互斥锁(mutex)同步共享变量的访问。

package mainimport ("fmt""sync"
)var counter int
var mu sync.Mutexfunc increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {mu.Lock()counter++mu.Unlock()}
}func main() {var wg sync.WaitGroupwg.Add(2)go increment(&wg)go increment(&wg)wg.Wait()fmt.Println("Final Counter:", counter)
}
示例二:未同步的读写操作

未同步的读写操作也是常见的数据竞争问题之一。以下是一个示例代码:

package mainimport ("fmt""sync"
)var counter intfunc readCounter(wg *sync.WaitGroup) {defer wg.Done()fmt.Println("Counter:", counter)
}func increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {counter++}
}func main() {var wg sync.WaitGroupwg.Add(3)go readCounter(&wg)go increment(&wg)go readCounter(&wg)wg.Wait()
}

解决方案:使用互斥锁(mutex)同步读写操作。

package mainimport ("fmt""sync"
)var counter int
var mu sync.Mutexfunc readCounter(wg *sync.WaitGroup) {defer wg.Done()mu.Lock()fmt.Println("Counter:", counter)mu.Unlock()
}func increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {mu.Lock()counter++mu.Unlock()}
}func main() {var wg sync.WaitGroupwg.Add(3)go readCounter(&wg)go increment(&wg)go readCounter(&wg)wg.Wait()
}

处理误报

在使用runtime/race包时,可能会遇到误报问题。以下是处理误报的一些方法:

  1. 仔细检查代码:确保所有共享变量的访问都已正确同步。
  2. 使用更严格的同步机制:在某些情况下,可以使用更严格的同步机制,如条件变量(condition variable)或读写锁(RWMutex),以减少误报的可能性。
  3. 忽略误报:如果确定某些检测信息是误报,可以选择忽略这些信息,但需谨慎操作,避免遗漏真实的数据竞争问题。

进阶技巧

在这一章中,我们将探讨一些高级数据竞争检测技巧,帮助你在复杂的并发程序中更好地使用runtime/race包。

高级数据竞争检测

使用条件变量

条件变量(condition variable)是一种高级同步原语,可以在某些情况下替代互斥锁(mutex)。以下是一个使用条件变量避免数据竞争问题的示例代码:

package mainimport ("fmt""sync"
)var counter int
var mu sync.Mutex
var cond = sync.NewCond(&mu)func increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {mu.Lock()counter++cond.Signal()mu.Unlock()}
}func readCounter(wg *sync.WaitGroup) {defer wg.Done()mu.Lock()cond.Wait()fmt.Println("Counter:", counter)mu.Unlock()
}func main() {var wg sync.WaitGroupwg.Add(2)go increment(&wg)go readCounter(&wg)wg.Wait()
}
使用读写锁

读写锁(RWMutex)是一种特殊的互斥锁,允许多个读操作同时进行,但写操作是独占的。以下是一个使用读写锁避免数据竞争问题的示例代码:

package mainimport ("fmt""sync"
)var counter int
var rw sync.RWMutexfunc increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 1000; i++ {rw.Lock()counter++rw.Unlock()}
}func readCounter(wg *sync.WaitGroup) {defer wg.Done()rw.RLock()fmt.Println("Counter:", counter)rw.RUnlock()
}func main() {var wg sync.WaitGroupwg.Add(3)go increment(&wg)go readCounter(&wg)go readCounter(&wg)wg.Wait()
}

race包与其他工具的结合

在实际开发中,可以将runtime/race包与其他数据竞争检测工具结合使用,以提高检测的准确性和全面性。

race包与静态分析工具结合使用

静态分析工具可以在代码编写阶段检测潜在的数据竞争问题,结合runtime/race包的动态检测,可以提供更全面的数据竞争检测方案。

使用并发测试工具

并发测试工具如GoConveyGinkgo等,可以帮助开发者编写和运行并发测试,结合runtime/race包,可以更有效地检测和解决并发问题。

结论

在本教程中,我们详细介绍了Golang runtime/race包的使用方法和技巧,通过丰富的代码示例和详细的解释,帮助你全面掌握这一工具的使用。通过在实际开发中使用runtime/race包,可以有效地检测和解决数据竞争问题,提高程序的稳定性和可靠性。

希望本教程对你有所帮助,并鼓励你在日常开发中积极使用runtime/race包,确保你的并发程序安全、可靠。数据竞争问题虽然复杂,但只要掌握了正确的工具和方法,就能轻松应对,编写出高质量的并发代码。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/474290.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Ascend C算子性能优化实用技巧05——API使用优化

Ascend C是CANN针对算子开发场景推出的编程语言&#xff0c;原生支持C和C标准规范&#xff0c;兼具开发效率和运行性能。使用Ascend C&#xff0c;开发者可以基于昇腾AI硬件&#xff0c;高效的实现自定义的创新算法。 目前已经有越来越多的开发者使用Ascend C&#xff0c;我们…

【HCIP]——OSPF综合实验

题目 实验需求 根据上图可得&#xff0c;实验需求为&#xff1a; 1.R5作为ISP&#xff1a;其上只能配置IP地址&#xff1b;R4作为企业边界路由器&#xff0c;出口公网地址需要通过PPP协议获取&#xff0c;并进行CHAP认证。&#xff08;PS&#xff1a;因PPP协议尚未学习&#…

深入理解Redis(七)----Redis实现分布式锁

基于Redis的实现方式 1、选用Redis实现分布式锁原因&#xff1a; &#xff08;1&#xff09;Redis有很高的性能&#xff1b; &#xff08;2&#xff09;Redis命令对此支持较好&#xff0c;实现起来比较方便 2、使用命令介绍&#xff1a; &#xff08;1&#xff09;SETNX SETNX …

Python-简单病毒程序合集(一)

前言&#xff1a;简单又有趣的Python恶搞代码&#xff0c;往往能给我们枯燥无味的生活带来一点乐趣&#xff0c;激发我们对编程的最原始的热爱。那么话不多说&#xff0c;我们直接开始今天的编程之路。 编程思路&#xff1a;本次我们将会用到os,paltform,threading,ctypes,sys,…

Web3浪潮下的区块链应用:从理论到实践的全面解析

随着Web3的兴起&#xff0c;区块链技术作为其核心支撑&#xff0c;正迎来前所未有的应用爆发。Web3不仅仅是技术的革新&#xff0c;更代表了一种去中心化、开放、透明的互联网愿景。在这一背景下&#xff0c;区块链技术的应用正从理论走向实践&#xff0c;推动着各行各业的数字…

网络安全:我们的安全防线

在数字化时代&#xff0c;网络安全已成为国家安全、经济发展和社会稳定的重要组成部分。网络安全不仅仅是技术问题&#xff0c;更是一个涉及政治、经济、文化、社会等多个层面的综合性问题。从宏观到微观&#xff0c;网络安全的重要性不言而喻。 宏观层面&#xff1a;国家安全与…

鸿蒙北向开发环境安装指南

境界一&#xff1a;昨夜西风凋碧树。独上高楼&#xff0c;望尽天涯路。----------王静安《人间词话》 单元一&#xff1a;鸿蒙开发工具的安装 学习目标 &#xff08;1&#xff09;完成鸿蒙开发工具Deveco Studio的安装。 任务1.1 下载DevEcoStudio 任务描述 DevEco Studi…

51单片机基础01 单片机最小系统

目录 一、什么是51单片机 二、51单片机的引脚介绍 1、VCC GND 2、XTAL1 2 3、RST 4、EA 5、PSEN 6、ALE 7、RXD、TXD 8、INT0、INT1 9、T0、T1 10、MOSI、MISO、SCK 11、WR、RD 12、通用IO P0 13、通用IO P1 14、通用IO P2 三、51单片机的最小系统 1、供电与…

golang开源框架:go开源验证框架validator

validator 单个字段格式验证 先来一个单个字段格式的验证 目录结构 在main函数中 package mainimport "awesomeProject/validate"func main() {validate.SingleFieldValidate() }在validator.go中 package validateimport ("github.com/go-playground/val…

计算机网络-MSTP基础实验一(单域多实例)

前面我们已经大致了解了MSTP的基本概念和工作原理&#xff0c;但是我自己也觉得MSTP的理论很复杂不结合实验是很难搞懂的&#xff0c;今天来做一个配套的小实验以及一些配置命令。 一、网络拓扑 单域多实例拓扑 基本需求&#xff1a;SW1为VLAN10的网关&#xff0c;SW2为VLAN20的…

智谱AI清影升级:引领AI视频进入音效新时代

前几天智谱推出了新清影,该版本支持4k、60帧超高清画质、任意尺寸&#xff0c;并且自带音效的10秒视频,让ai生视频告别了"哑巴时代"。 智谱AI视频腾空出世&#xff0c;可灵遭遇强劲挑战&#xff01;究竟谁是行业翘楚&#xff1f;(附测评案例)之前智谱出世那时体验了一…

商业物联网详细指南:优势与挑战

物联网是信息技术行业最具前景的领域之一。为什么它如此热门呢&#xff1f;原因在于全球连接性。设备可以像人群一样相互协作。正如我们所知&#xff0c;协作能显著提高生产力。 物联网对普通用户和企业都有益处。许多日常流程可以通过传感器、扫描仪、摄像头和其他设备实现自…

css uniapp背景图宽度固定高度自适应可以重复

page {height: 100%;background-image: url(https://onlinekc.a.hlidc.cn/uploads/20241115/350f94aaf493d05625a7ddbc86c7804e.png);background-repeat: repeat;background-size: contain;} 如果不要重复 把background-repeat: repeat;替换background-repeat: no-repeat;

学习日志012--python中多进程,多线程

简简单单小练习 1.线程的并发执行 import threading import time# 创建要执行的两个函数 def print_hello():for _ in range(10):print("hello")time.sleep(1)def print_world():for _ in range(10):print("world")time.sleep(1)# 创建线程对象 注意这里…

网络传输:网卡、IP、网关、子网掩码、MAC、ARP、路由器、NAT、交换机

目录 网卡IP网络地址主机地址子网子网掩码网关默认网关 MACARPARP抓包分析 路由器NATNAPT 交换机 网卡 网卡(Network Interface Card&#xff0c;简称NIC)&#xff0c;也称网络适配器。 OSI模型&#xff1a; 1、网卡工作在OSI模型的最后两层&#xff0c;物理层和数据链路层。物…

Ubuntu 22.04 上快速搭建 Samba 文件共享服务器

Samba 简介 Samba 是一个开源软件&#xff0c;它扮演着不同操作系统间沟通的桥梁。通过实现 SMB&#xff08;Server Message Block&#xff09;协议&#xff0c;Samba 让文件和打印服务在 Windows、Linux 和 macOS 之间自由流动。 以下是 Samba 的特点&#xff1a; 跨平台兼…

stm32启动过程解析startup启动文件

1.STM32的启动过程模式 1.1 根据boot引脚决定三种启动模式 复位后&#xff0c;在 SYSCLK 的第四个上升沿锁存 BOOT 引脚的值。BOOT0 为专用引脚&#xff0c;而 BOOT1 则与 GPIO 引脚共用。一旦完成对 BOOT1 的采样&#xff0c;相应 GPIO 引脚即进入空闲状态&#xff0c;可用于…

CVE-2024-2961漏洞的简单学习

简单介绍 PHP利用glibc iconv()中的一个缓冲区溢出漏洞&#xff0c;实现将文件读取提升为任意命令执行漏洞 在php读取文件的时候可以使用 php://filter伪协议利用 iconv 函数, 从而可以利用该漏洞进行 RCE 漏洞的利用场景 PHP的所有标准文件读取操作都受到了影响&#xff1…

视觉SLAM相机——单目相机、双目相机、深度相机

一、单目相机 只使用一个摄像头进行SLAM的做法称为单目SLAM&#xff0c;这种传感器的结构特别简单&#xff0c;成本特别低&#xff0c;单目相机的数据&#xff1a;照片。照片本质上是拍摄某个场景在相机的成像平面上留下的一个投影。它以二维的形式记录了三维的世界。这个过程中…

Java通过calcite实时读取kafka中的数据

引入maven依赖 <dependency> <groupId>org.apache.calcite</groupId> <artifactId>calcite-kafka</artifactId> <version>1.28.0</version> </dependency> 测试代码 import java.sql.Connection; import java.sql.DriverMan…