Go学习第十一章——协程goroutine与管道channel

Go协程goroutine与管道channel

      • 1 协程goroutine
        • 1.1 基本介绍
        • 1.2 快速入门
        • 1.3 调度模型：MPG模式介绍
        • 1.4 设置cpu数
        • 1.5 协程资源竞争问题
        • 1.6 解决协程并发方案
      • 2 管道channel
        • 2.1 基本介绍
        • 2.2 快速入门
        • 2.3 管道的关闭和遍历
        • 2.4 管道和协程的结合
        • 2.5 声明 只读/只写 的管道
        • 2.6 select解决管道堵塞
        • 2.7 recover解决程序崩溃

1 协程goroutine

1.1 基本介绍

前置知识：“进程和线程”，“并发与并行”

  1. 协程的概念

协程（Coroutine）是一种用户态的轻量级线程，不同于操作系统线程，协程能够在单个线程中实现多任务并发，使用更少的系统资源。协程的运行由程序控制，不需要操作系统介入，因此协程之间的切换更加快速。

  1. Go语言中的协程

在Go语言中，协程被称为“Goroutine”，是一种轻量级的线程。与操作系统线程不同，Go语言的Goroutine只需要几kb的内存，并且可以很容易地创建数千个Goroutine，因为它们由Go运行时（Goruntime）自动管理。

Go协程和Go主线程

  1. Go主线程（有程序员直接称为线程/也可以理解成进程）：一个Go线程上，可以起多个协程，你可以这样理解，协程是轻量级的线程[编译器做优化]。
  2. Go协程的特点：
  • 有独立的栈空间
  • 共享程序堆空间
  • 调度由用户控制
  • 协程是轻量级的线程

image-20231026204414624

1.2 快速入门

案例说明：

  1. 在主线程(可以理解成进程)中，开启一个goroutine，该协程每隔1秒输出 “hello，world”。
  2. 在主线程中也每隔一秒输出"hello,golang"，输出10次后，退出程序。
  3. 要求主线程和goroutine同时执行。
func test() {
	for i := 1; i < 10; i++ {
		fmt.Println("协程 test() hello, world" + strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}

func main() {

	// 开启协程
	go test()

	for i := 1; i < 10; i++ {
		fmt.Println("主线程 main() hello, world" + strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}

输出结果：

主线程 main() hello, world1
协程 test() hello, world1
协程 test() hello, world2
主线程 main() hello, world2
主线程 main() hello, world3
协程 test() hello, world3
略。。。

从输出结果就可以看出来，这两个是交替输出的，就是并发执行~

小结：

  1. 主线程是一个物理线程，直接作用在cpu上的，是重量级的，非常消费cpu资源。

  2. 协程从主线程开启的，是轻量级的线程，是逻辑态。对资源消耗相对较小。

  3. Golang的协程机制是重要的特点，可以轻松的开启上万个协程。其他编程语言的并发机制是一般基于线程的，开启过多的线程，资源消费大，这里就突显Golang在并发上的优势了。

1.3 调度模型：MPG模式介绍

这里只是简单的讲一下，具体可以去网上找找文章

  1. M：操作系统的主线程（是物理线程）
  2. P：协程执行需要的上下文（需要的资源等）
  3. G：协程

状态一：

image-20231026211735141

状态二：

image-20231026211824874

1.4 设置cpu数

介绍：为了充分的利用多cpu的优势，在Golang程序中，设置运行的cpu数目。

image-20231026212556960

使用的函数：func NumCPU

功能：NumCPU返回本地机器的逻辑CPU个数。

函数的代码如下：

func NumCPU() int

使用案例：

func main() {
	// 获取当前系统cpu的数量
	num := runtime.NumCPU()
	// 我这里设置num-1的cpu运行go程序
	runtime.GOMAXPROCS(num)
	fmt.Println("num=", num)
}

输出结果：num= 16

  1. go 1.8 后，默认让程序运行在多个核上，可以不用设置了。
  2. go 1.8 前，还是要设置一下，可以更新的利用cpu。
1.5 协程资源竞争问题

**需求：**现在要计算1-200的各个数的阶乘，并且把各个数的阶乘放入到map中。最后显示出来。要求使用goroutine完成。

分析思路：

  1. 使用goroutine来完成，效率搞，但是会出现并发/并行安全问题。
  2. 这里就提出了不同goroutine如何通信的问题。

代码实现：

  1. 使用goroutine来完成（看看使用gorotine并发完成会出现什么问题？然后我们会去解决）
  2. 在运行某个程序是，如何知道是否存在资源竞争问题。方法很简单，在编译该程序时，增加一个参数 -race即可。

思路

  1. 编写一个函数，来计算各个数的阶乘，并放入到 map中。
  2. 我们启动的协程多个，统计的将结果放入到 map中。
  3. map 应该做出一个全局的。

初步代码：

var (
	myMap = make(map[int]int, 10)
)

// test 函数就是计算 n!, 让将这个结果放入到 myMap
func test(n int) {

	res := 1
	for i := 1; i <= n; i++ {
		res *= i
	}
}

func main() {

	// 我们这里开启多个协程完成这个任务[200个]
	for i := 1; i <= 20; i++ {
		go test(i)
	}

	//我们输出结果，变量这个
	for i, v := range myMap {
		fmt.Printf("map[%d]=%d\n", i, v)
	}
}

输出结果：无？？？什么都没有？？为啥呢？因为主线程提前结束了，在协程结束前结束了，就什么都没有！！

下一步：我们让主线程休眠10秒钟

添加代码：

//休眠10秒钟【第二个问题 】
time.Sleep(time.Second * 5)

再运行，会发现竟然报错了：

image-20231026214720689

也就是报错显示，恐怖错误，并发向协程做了写操作。

为啥？

因为，map是不安全的，也就是，200个线程同时向map里面写操作，导致并发问题。

所以现在有两个问题：

  1. map是不安全的，导致并发问题。
  2. 主线程休眠时间无法确定。
1.6 解决协程并发方案
  1. 声明一个全局的互斥锁，当第一个线程进行写操作，其他的线程没办法进去操作并且进入一个队列(数据结构)进行排队。
var (
	myMap = make(map[int]int, 10)
	//声明一个全局的互斥锁
	//lock 是一个全局的互斥锁，
	//sync 是包: synchornized 同步
	//Mutex : 是互斥
	lock sync.Mutex
)

func test(n int) {

	res := 1
	for i := 1; i <= n; i++ {
		res *= i
	}

	//这里我们将 res 放入到myMap
	//加锁
	lock.Lock()
	myMap[n] = res //concurrent map writes?
	//解锁
	lock.Unlock()
}

func main() {

	// 我们这里开启多个协程完成这个任务[200个]
	for i := 1; i <= 20; i++ {
		go test(i)
	}
	
	//这里我们输出结果,变量这个结果
	lock.Lock()
	for i, v := range myMap {
		fmt.Printf("map[%d]=%d\n", i, v)
	}
	lock.Unlock()
}

输出结果：会发现没有问题~~

image-20231026215652374

2 管道channel

虽然上面的方式解决了这个问题，但是不够完美，包括官方也说了，加锁是比较低级的做法，所以就引出了管道。

为什么需要channel

  1. 前面使用全局变量加锁同步来解决goroutine的通讯，但不完美

  2. 主线程在等待所有goroutine全部完成的时间很难确定，我们这里设置10秒，仅仅是估算。

  3. 如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有goroutine处于工作状态，这时也会随主线程的退出而销毁

  4. 通过全局变量加锁同步来实现通讯，也并不利用多个协程对全局变量的读写操作。

  5. 上面种种分析都在呼唤一个新的通讯机制-channel

2.1 基本介绍
  1. chanel 本质就是一个数据结构-队列
  2. 数据是先进先出【FIFO】
  3. 线程安全，多goroutine 访问时，不需要加锁，就是说channel 本身就是线程安全的。
  4. channel 有类型的，一个 string 的channel 只能存放string类型数据。

image-20231026220500713

2.2 快速入门

定义/声明channel

var 变量名 chen 数据类型

说明：

  1. channel是引用类型
  2. channel必须初始化才能写入数据，即make后才能使用。
  3. 管道是有类型的，intChan 只能写入整数int

案例入门：

func main() {

    //演示一下管道的使用
    //1. 创建一个可以存放3个int类型的管道
    var intChan chan int
    intChan = make(chan int, 3)

    //2. 看看intChan是什么
    fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n", intChan, &intChan)
}

输出结果：

intChan 的值=0xc000014700 intChan本身的地址=0xc00005e020

下面我们试一下向管道写入数据和读取数据

func main() {

	//演示一下管道的使用
	//1. 创建一个可以存放3个int类型的管道
	var intChan chan int
	intChan = make(chan int, 3)

	//2. 看看intChan是什么
	fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n", intChan, &intChan)

	//3. 向管道写入数据
	intChan<- 10
	num := 211
	intChan<- num
	intChan<- 50
	// //如果从channel取出数据后，可以继续放入
	<-intChan
	intChan<- 98//注意点, 当我们给管写入数据时，不能超过其容量


	//4. 看看管道的长度和cap(容量)
	fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan)) // 3, 3

	//5. 从管道中读取数据

	var num2 int
	num2 = <-intChan
	fmt.Println("num2=", num2)
	fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan))  // 2, 3

	//6. 在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报告 deadlock

	num3 := <-intChan
	num4 := <-intChan

	//num5 := <-intChan

	fmt.Println("num3=", num3, "num4=", num4/*, "num5=", num5*/)
}

输出结构：

intChan 的值=0xc000014700 intChan本身的地址=0xc00005e020
channel len= 3 cap=3
num2= 211
channel len= 2 cap=3
num3= 50 num4= 98
2.3 管道的关闭和遍历

channel的关闭

使用内置函数close可以关闭chanel，当channel关闭后，就不能再向channel写数据了，但是仍让可以从该channel读数据。

channel的遍历

channel支持for-range的方式进行遍历，请注意两个心结

  1. 在遍历时，如果channel没有关闭，则会出现deadlock的错误。
  2. 在遍历时，如果channel已经关闭，则会正常遍历数据，遍历完后，就会退出遍历。

代码演示：

func main() {

    intChan := make(chan int, 3)
    intChan <- 100
    intChan <- 200
    close(intChan) // close
    //这是不能够再写入数到channel
    //intChan<- 300
    fmt.Println("okook~")
    //当管道关闭后，读取数据是可以的
    n1 := <-intChan
    fmt.Println("n1=", n1)

    //遍历管道
    intChan2 := make(chan int, 100)
    for i := 0; i < 10; i++ {
       intChan2 <- i * 2 //放入10个数据到管道
    }

    //遍历管道不能使用普通的 for 循环
    // for i := 0; i < len(intChan2); i++ {

    // }
    //在遍历时，如果channel没有关闭，则会出现deadlock的错误
    //在遍历时，如果channel已经关闭，则会正常遍历数据，遍历完后，就会退出遍历
    close(intChan2)
    for v := range intChan2 {
       fmt.Println("v=", v)
    }
}

输出结果：

okook~
n1= 100
v= 0   
v= 2   
v= 4   
v= 6   
后面略~~~
2.4 管道和协程的结合

需求:
要求统计 1-80000 的数字中，哪些是素数?

下面是思路分析图：

image-20231026223927309

  1. 创建一个管道intChan，用来存这8000个数，设置容量1000
  2. 创建一个协程，将1到8000放到这个inChan管道里
  3. 创建一个管道primeChan，用来储存素数，只要是素数都存进来
  4. 创建四个协程，从inChan管道里取数，并计算受否为素数，如果是素数就放到primeChan里
  5. 那怎么确认协程传输完毕，然后把管道关掉？
  6. 创建一个管道exitChan，这里是四个协程，那就容量为4
  7. 当这四个协程取不到数的时候，就会向exitChan管道，传一个True，表示结束
  8. 主线程进行一个循环取exitChan，当取出来的数达到四个的时候，就关闭，这两个管道
package main

import (
	"fmt"
	"time"
)

// 向 intChan放入 1-100个数
func putNum(intChan chan int) {

	for i := 1; i <= 100; i++ {
		intChan <- i
	}

	//关闭intChan
	close(intChan)
}

// 从 intChan取出数据，并判断是否为素数,如果是，就
//
//	//放入到primeChan
func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {

	//使用for 循环
	// var num int
	var flag bool //
	for {
		//time.Sleep(time.Millisecond * 10)
		num, ok := <-intChan //intChan 取不到..

		if !ok {
			break
		}
		flag = true //假设是素数
		//判断num是不是素数
		for i := 2; i < num; i++ {
			if num%i == 0 { //说明该num不是素数
				flag = false
				break
			}
		}

		if flag {
			//将这个数就放入到primeChan
			primeChan <- num
		}
	}

	fmt.Println("有一个primeNum 协程因为取不到数据，退出")
	//这里我们还不能关闭 primeChan
	//向 exitChan 写入true
	exitChan <- true
}

func main() {

	intChan := make(chan int, 100)
	primeChan := make(chan int, 100) //放入结果
	//标识退出的管道
	exitChan := make(chan bool, 8) // 4个

	start := time.Now().Unix()

	//开启一个协程，向 intChan放入 1-8000个数
	go putNum(intChan)
	//开启4个协程，从 intChan取出数据，并判断是否为素数,如果是，就
	//放入到primeChan
	for i := 0; i < 8; i++ {
		go primeNum(intChan, primeChan, exitChan)
	}

	//这里我们主线程，进行处理
	//直接
	go func() {
		for i := 0; i < 8; i++ {
			<-exitChan
		}

		end := time.Now().Unix()
		fmt.Println("使用协程耗时=", end-start)

		//当我们从exitChan 取出了4个结果，就可以放心的关闭 prprimeChan
		close(primeChan)
	}()
	res := make([]int, 0)
	//遍历我们的 primeChan ,把结果取出
	for {
		data, ok := <-primeChan
		if !ok {
			break
		}
		res = append(res, data)
	}
	fmt.Printf("100的素数有: %v个，分别是：%v \n", len(res), res)
	fmt.Println("main线程退出")
}

输出结果：

有一个primeNum 协程因为取不到数据，退出
有一个primeNum 协程因为取不到数据，退出
有一个primeNum 协程因为取不到数据，退出
有一个primeNum 协程因为取不到数据，退出
有一个primeNum 协程因为取不到数据，退出
有一个primeNum 协程因为取不到数据，退出
有一个primeNum 协程因为取不到数据，退出
有一个primeNum 协程因为取不到数据，退出
使用协程耗时= 0
100的素数有: 26个，分别是：[1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97]
main线程退出

补充：这里用了一个记录协程消耗时间的方法

start := time.Now().Unix()
end := time.Now().Unix()
fmt.Println("使用协程耗时=", end-start)

补充知识：管道阻塞

在使用channel通道进行数据传递时，接收方从通道中获取数据的操作可以是阻塞的。具体来说，有以下几种情况会导致接收方的操作阻塞：

  1. 通道中没有可用的数据：当接收方尝试从一个没有数据的通道中获取数据时，它将被阻塞，等待通道中有数据可供接收。
  2. 通道中没有发送者：如果通道已经关闭，并且没有任何Goroutine发送数据到该通道，接收方将永久地阻塞在接收操作中。
  3. 通道中发送数据速度过慢：如果接收方的处理速度快于发送方的发送速度，那么接收方在获取到一条数据后，等待一段时间后可能会发现再次从通道中获取的数据仍然不可用，因此接收方将再次被阻塞。
  4. 管道未关闭进行遍历操作：在遍历通道时，如果通道没有被关闭，并且发送方没有向通道发送数据，接收方的遍历操作会被阻塞。

需要注意的是，当通道被阻塞时，程序的执行仍然会继续，只是被阻塞的Goroutine会暂停执行，直到满足接收操作的条件。

2.5 声明 只读/只写 的管道

channel可以声明为只读，或者只写性质。

var chan1 chan<- int // 声明为只写
var chan2 <-chan int// 声明为只写

注意：如果在一个协程里传入了一个管道，并且设置它只读只写，那么，因为作用域，就只在这个协程里面是属于只读只写的情况，可以防止一下误操作。

image-20231026231716594

2.6 select解决管道堵塞

使用select可以解决从管道取数据的阻塞问题

案例代码，自学理解：

func main() {
    //使用select可以解决从管道取数据的阻塞问题

    //1.定义一个管道 10个数据int
    intChan := make(chan int, 10)
    for i := 0; i < 10; i++ {
       intChan <- i
    }
    //2.定义一个管道 5个数据string
    stringChan := make(chan string, 5)
    for i := 0; i < 5; i++ {
       stringChan <- "hello" + fmt.Sprintf("%d", i)
    }

    //传统的方法在遍历管道时，如果不关闭会阻塞而导致 deadlock

    //问题，在实际开发中，可能我们不好确定什么关闭该管道.
    //可以使用select 方式可以解决
    //label:
    for {
       select {
       //注意: 这里，如果intChan一直没有关闭，不会一直阻塞而deadlock
       //，会自动到下一个case匹配
       case v := <-intChan:
          fmt.Printf("从intChan读取的数据%d\n", v)
          time.Sleep(time.Second)
       case v := <-stringChan:
          fmt.Printf("从stringChan读取的数据%s\n", v)
          time.Sleep(time.Second)
       default:
          fmt.Printf("都取不到了，不玩了, 程序员可以加入逻辑\n")
          time.Sleep(time.Second)
          return
          //break label
       }
    }
}

这样就能够解决啦~~~

2.7 recover解决程序崩溃

**说明：**如果我们起了一个协程，但是这个协程出现了panic，如果我们没有捕获这个panic，就会早晨整个程序崩溃，这时我，1可以砸爱goroutine中使用recover来捕获panic，进行处理，这样即使这个协程发生了问题，但是主线程仍然不受影响，可以继续执行。

// 函数
func sayHello() {
    for i := 0; i < 10; i++ {
       time.Sleep(time.Second)
       fmt.Println("hello,world")
    }
}

// 函数
func test() {
    //这里我们可以使用defer + recover
    defer func() {
       //捕获test抛出的panic
       if err := recover(); err != nil {
          fmt.Println("test() 发生错误", err)
       }
    }()
    //定义了一个map
    var myMap map[int]string
    myMap[0] = "golang" //error
}

func main() {

    go sayHello()
    go test()

    for i := 0; i < 10; i++ {
       fmt.Println("main() ok=", i)
       time.Sleep(time.Second)
    }

}

输出结果：

main() ok= 0
test() 发生错误 assignment to entry in nil map
main() ok= 1
hello,world
hello,world
main() ok= 2
略~~~

Over！！！！坚持就是胜利！！兄弟们！！！冲冲冲！！！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

GZ035 5G组网与运维赛题第2套

GZ035 5G组网与运维赛题第2套

2023年全国职业院校技能大赛 GZ035 5G组网与运维赛项（高职组） 赛题第2套 一、竞赛须知 1.竞赛内容分布 竞赛模块1--5G公共网络规划部署与开通（35分） 子任务1：5G公共网络部署与调试（15分） 子任务2：5G室内与室外站点建设（20分） 竞赛模块2--5G公共网络运维与优化（…
阅读更多...
Codeforces Round 905 (Div. 3)ABCDEF

Codeforces Round 905 (Div. 3)ABCDEF

Codeforces Round 905 (Div. 3) 目录 A. Morning题意思路核心代码 B. Chemistry题意思路核心代码 C. Raspberries题意思路核心代码 D. In Love题意思路核心代码 E. Look Back题意思路核心代码 A. Morning 题意 从一开始&#xff0c;每一次操作可以选择当前的数字打印或者是移…
阅读更多...
Vue3 + Tsx 集成 ace-editor编辑器

Vue3 + Tsx 集成 ace-editor编辑器

Ace Editor介绍 Ace Editor&#xff08;全名&#xff1a;Ajax.org Cloud9 Editor&#xff09;是一个开源的代码编辑器&#xff0c;旨在提供强大的代码编辑功能&#xff0c;通常用于构建基于Web的代码编辑应用程序。它最初由Cloud9 IDE开发&#xff0c;现在由开源社区维护。 主…
阅读更多...
C++ 左值、右值、左值引用以及右值引用

C++ 左值、右值、左值引用以及右值引用

一、左值和右值 将亡值 1.左值 左值是一个表示数据的表达式&#xff0c;比如&#xff1a;变量名、解引用的指针变量。一般地&#xff0c;我们可以获取它的地址和对它赋值&#xff0c;但被 const 修饰后的左值&#xff08;常性&#xff09;&#xff0c;不能给它赋值&#xff0…
阅读更多...
【安装tensorflow-CPU版本】

【安装tensorflow-CPU版本】

一、安装目的二、安装过程三、总结 一、安装目的 使自己的jupyter能用tensorflow 二、安装过程 首先打开anaconda prompt 接着输入conda list 查看自己是否安装了tensorflow 在 Python 中使用 pip 工具来升级 pip 自身并指定了使用清华大学的镜像源进行安装 python -m pip …
阅读更多...
手写Vue渲染器render函数

手写Vue渲染器render函数

使用js对象来描述UI更加的灵活。“这种对象”在vue框架中被称为虚拟DOM&#xff0c;渲染函数内部可以创建虚拟DOM&#xff0c;然后vue.js可以将其内容进行渲染。 1.渲染器的介绍 渲染器的作用就是把虚拟DOM渲染为真实DOM 思考下&#xff0c;我们有一个虚拟 DOM&#xff0c;如…
阅读更多...
K8s概念汇总-笔记

K8s概念汇总-笔记

目录 1.Master 1.1在Master上运⾏着以下关键进程 2.什么是Node? 1.2在每个Node上都运⾏着以下关键进程 3.什么是 Pod ? 4. 什么是Label &#xff1f; 5.Replication Controller 6.Deployment 6.1Deployment的典型场景&#xff1a; 7.Horizontal Pod Autoscaler TODO…
阅读更多...
【计算机毕设小程序案例】基于SpringBoot的小演员招募小程序

【计算机毕设小程序案例】基于SpringBoot的小演员招募小程序

前言&#xff1a;我是IT源码社&#xff0c;从事计算机开发行业数年&#xff0c;专注Java领域&#xff0c;专业提供程序设计开发、源码分享、技术指导讲解、定制和毕业设计服务 &#x1f449;IT源码社-SpringBoot优质案例推荐&#x1f448; &#x1f449;IT源码社-小程序优质案例…
阅读更多...
Linux mkdir命令：创建目录（文件夹）

Linux mkdir命令：创建目录（文件夹）

mkdir 命令&#xff0c;是 make directories 的缩写&#xff0c;用于创建新目录&#xff0c;此命令所有用户都可以使用。mkdir 命令的基本格式为&#xff1a; [rootlocalhost ~]# mkdir [-mp] 目录名 -m 选项用于手动配置所创建目录的权限&#xff0c;而不再使用默认权限。 -p…
阅读更多...
[ubuntu系统下的文本编辑器nano,vim,gedit，文件使用，以及版本更新问题]

[ubuntu系统下的文本编辑器nano,vim,gedit，文件使用，以及版本更新问题]

文本编辑器概要 在Ubuntu系统下&#xff0c;有许多文本编辑器可供选择&#xff0c;每个编辑器都有其独特的特性和用途。以下是一些常见的文本编辑器&#xff1a; Gedit&#xff1a; 这是Ubuntu默认的文本编辑器&#xff0c;它简单易用&#xff0c;适合基本的文本编辑任务。 安…
阅读更多...
银河麒麟v10x86或者arm离线安装服务

银河麒麟v10x86或者arm离线安装服务

银河麒麟v10x86或者arm离线安装服务 最近有个项目&#xff0c;甲方的服务器用的全是国产化服务器银河麒麟&#xff0c;架构是x86的然后也无法连接外网&#xff0c;需要离线安装服务正常思路就是找到离线安装的包&#xff0c;然后拷贝到现场的服务器中进行安装所以问题就在于如…
阅读更多...
墨西哥专线相关问题快问快答

墨西哥专线相关问题快问快答

随着全球贸易的不断发展&#xff0c;越来越多的企业在寻求更便捷、高效的物流解决方案。墨西哥专线作为一种跨境物流方式&#xff0c;受到了越来越多企业的关注。本文将为您解答关于墨西哥专线的相关问题&#xff0c;帮助您更好地了解和运用这一物流方式。 一、墨西哥专线是什么…
阅读更多...
Prompt设计与大语言模型微调

Prompt设计与大语言模型微调

本文主要介绍了Prompt设计、大语言模型SFT和LLM在手机天猫AI导购助理项目应用。 ChatGPT基本原理 “会说话的AI”&#xff0c;“智能体” 简单概括成以下几个步骤&#xff1a; 预处理文本&#xff1a;ChatGPT的输入文本需要进行预处理。输入编码&#xff1a;ChatGPT将经过预处理…
阅读更多...
MySQL 概述 数据库表操作 数据增删改

MySQL 概述 数据库表操作 数据增删改

目录 MySQL概述前言安装与配置MySQL登录与卸载 数据模型概述SQL简介SQL通用语法简介SQL分类 数据库设计(数据库操作)-DDL数据库操作查询数据库 show databases、select database()创建数据库 create database使用数据库 use删除数据库 drop database 图形化工具连接数据库操作数…
阅读更多...
zk-Bench：SNARKs性能对比评估工具

zk-Bench：SNARKs性能对比评估工具

1. 引言 JENS ERNSTBERGER等人2023年论文《zk-Bench: A Toolset for Comparative Evaluation and Performance Benchmarking of SNARKs》。 zk-Bench&#xff0c;定位为&#xff1a; 定位为首个公钥密码学性能评估基准测试框架和工具&#xff0c;重点关注通用ZKP系统的实测评…
阅读更多...
【Vue3-Flask-BS架构Web应用】实践笔记1-使用一个bat脚本自动化完整部署环境

【Vue3-Flask-BS架构Web应用】实践笔记1-使用一个bat脚本自动化完整部署环境

前言 近年来&#xff0c;Web开发已经成为计算机科学领域中最热门和多产的领域之一。Python和Vue.js是两个备受欢迎的工具&#xff0c;用于构建现代Web应用程序。在本教程中&#xff0c;我们将探索如何使用这两个工具来创建一个完整的Web项目。我们将完成从安装Python和Vue.js到…
阅读更多...
ESP8266,手机与电脑之间的TCP通讯

ESP8266,手机与电脑之间的TCP通讯

电脑端运行通讯猫调试助手,作为服务端: 电脑端 电脑的IP地址是: 192.168.2.232 手机与电脑之间的TCP通讯 手机端运行网络调试精灵,作为客户端: 手机端 如果从手机端点击"发送"按钮,则也会将"ghhh东方红广场"几个字发送到电脑上(服务端). ESP8266作为客户…
阅读更多...
存储器概述

存储器概述

一、存储系统基本概念
阅读更多...
垃圾回收系统小程序

垃圾回收系统小程序

在当今社会&#xff0c;废品回收不仅有利于环境保护&#xff0c;也有利于资源的再利用。随着互联网技术的发展&#xff0c;个人废品回收也可以通过小程序来实现。本文将介绍如何使用乔拓云网制作个人废品回收小程序。 1. 找一个合适的第三方制作平台/工具&#xff0c;比如乔拓云…
阅读更多...
正点原子嵌入式linux驱动开发——RGB转HDMI

正点原子嵌入式linux驱动开发——RGB转HDMI

目前大多数的显示器都提供了HDMI接口&#xff0c;HDMI的应用范围也越来越广&#xff0c;但是STM32MP157这颗芯片原生并不支持HDMI显示。可以通过RGB转HDMI芯片将RGB信号转为HDMI信号&#xff0c;这样就可以连接HDMI显示器了。本章就来学习一下如何在正点原子的STM32MP1开发板上…
阅读更多...
最新文章

Copyright @ 2022~2023