怎么用golang实现一个简易版c++的FIFO队列？

什么是消息队列？

• 消息队列（Message Queue）是一种在不同应用程序或组件之间进行异步通信的中间件技术。它主要用于解耦系统中的各个组件，使得它们可以独立地运行和扩展，同时提高系统的可靠性和性能。

• 消息队列的工作原理是，发送者将消息发送到队列中，接收者从队列中获取消息进行处理。发送者和接收者不需要直接相互通信，它们只需要与消息队列进行交互。这样可以避免发送者和接收者之间的直接依赖，提高系统的灵活性和可维护性。

• 消息队列通常具有以下特点：

  • 异步通信：发送者不需要等待接收者处理完消息后再进行下一步操作，可以立即返回继续执行其他任务。
  • 解耦：系统中的各个组件之间不需要直接相互通信，只需要与消息队列进行交互，从而降低了组件之间的耦合度。
  • 可靠性：消息队列通常会将消息持久化存储，确保消息不会丢失。即使接收者出现故障，消息也可以在接收者恢复后继续被处理。
  • 可扩展性：可以根据系统的负载情况动态地增加或减少消息队列的消费者数量，提高系统的吞吐量。

用Golang怎么实现？

• 废话不多说，直接上代码（复制可直接使用）

package main

import "fmt"

type queue[T any] struct {
	capacity int32
	size     int32
	ch       chan T
}

func NewQueue[T any](capacity int32) *queue[T] {
	q := new(queue[T])
	q.Init(capacity)
	return q
}

func (q *queue[T]) Init(capacity int32) {
	q.capacity = capacity
	q.size = 0
	q.ch = make(chan T, capacity)
}

func (q *queue[T]) Push(v T) {
	if q.size == q.capacity {
		fmt.Println("触发扩容")
		nch := make(chan T, 2*q.capacity)
		for i := int32(0); i < q.size; i++ {
			nch <- <-q.ch
		}
		q.ch = nch
		q.capacity *= 2
	}
	q.ch <- v
	q.size += 1
}

func (q *queue[T]) Pop() *T {
	if q.size == 0 {
		return nil
	}
	q.size -= 1
	v := <-q.ch
	if q.size == q.capacity/2 {
		fmt.Println("触发缩容")
		nch := make(chan T, q.capacity/2)
		for i := int32(0); i < q.size; i++ {
			nch <- <-q.ch
		}
		q.ch = nch
		q.capacity /= 2
	}
	return &v
}

func (q *queue[T]) Size() int32 {
	return q.size
}

type test struct {
	I int32
}

func main() {
	// 封装一个队列数据结构，push，pop
	//Queue.Init(2)
	q := NewQueue[int32](2)
	q.Push(1)
	q.Push(2)
	q.Push(3)
	q.Push(4)
	q.Push(5)

	fmt.Println(q.Pop())
	fmt.Println(q.Pop())
	fmt.Println(q.Pop())
	fmt.Println(q.Pop())

	q1 := NewQueue[test](2)
	q1.Push(test{1})
	q1.Push(test{2})
	q1.Push(test{3})
	q1.Push(test{4})
	q1.Push(test{5})

	fmt.Println(q1.Pop())
	fmt.Println(q1.Pop())
	fmt.Println(q1.Pop())
	fmt.Println(q1.Pop())
}