golang队列任务处理

单任务队列耗时

package main

import (
	"crypto/rand"
	"fmt"
	"math/big"
	"strconv"
	"strings"
	"sync"
	"time"
)

type task struct {
	id       uint32 //
	callback chan int
}

var chTask = make(chan task)

var wg sync.WaitGroup

var arr = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

func main() {
	go working(chTask) // 就一个工厂开门（单任务队列）
	start := time.Now().UnixNano()
	for i := 0; i < 100; i++ {
		wg.Add(1)  // 线程计数器+1
		go order() // 给工厂派活
	}
	wg.Wait() // 等待所有任务处理完毕
	fmt.Printf("所有任务已执行完毕，用时%v", time.Now().UnixNano()-start)
}

// 出任务的，甲方爸爸
func order() {
	id := randomString(10)                       // 获取订单编号
	callack := make(chan int)                    // 把返程的招呼打好
	t := task{id: uint32(id), callback: callack} // 订单起草完毕
	chTask <- t                                  // 把订单交给小弟让他送送工厂去
	msg := <-callack                             // 拿到工厂编号
	_ = msg
	wg.Done() // 线程计数器-1
}

// 工厂，接收小弟(chan)，返回工厂编号
func working(chTasks chan task) {
	for {
		t := <-chTasks // 卸货
		id := t.id     // 订单编号
		//_ = id            // 此处生产产品（业务逻辑）
		for i := 0; i < 1000000; i++ {
			_ = id
		}
		t.callback <- 1 // 返回工厂编号
	}

}

// 生成订单号
func randomString(n int) uint32 {
	var b []string
	for i := 0; i < n; i++ {
		num, _ := rand.Int(rand.Reader, big.NewInt(int64(len(arr))))
		// 1.将 *big.Int 转化为 int64
		// 2.将 int 64 转化为 int
		// 3.将 int 转化为 string
		b = append(b, strconv.Itoa(arr[int(num.Int64())]))
	}

	str := strings.Join(b, "") // 拼接字符串
	a, _ := strconv.Atoi(str)  // string 转 int
	yes := uint32(a)           // int 转 uint32
	return yes
}

结果：所有任务已执行完毕，用时180531600

 

多任务队列耗时

package main

import (
	"crypto/rand"
	"fmt"
	"math/big"
	"strconv"
	"strings"
	"sync"
	"time"
)

type task struct {
	id       uint32   // 订单编号
	callback chan int // 工厂编号
}

const taskNum = 16                          // 准备找16个工厂
var chTaskList = make([]chan task, taskNum) // 工厂列表

var wg sync.WaitGroup

var arr = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

func task_init() {
	for i := 0; i < taskNum; i++ {
		wg.Add(1)
		chTaskList[i] = make(chan task) // 工厂登记
		go working(chTaskList[i], i)    // 工厂开门大吉，待命中
	}
}

func main() {
	// start := time.Now().UnixNano()

	task_init() // 工厂就绪
	wg.Wait()   // 等待所有工厂就绪

	start := time.Now().UnixNano()
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go order() // 给工厂派活
	}

	wg.Wait() // 等待所有任务处理完毕

	fmt.Printf("所有任务已执行完毕，用时%v",time.Now().UnixNano() - start)

}

// 出任务的，甲方爸爸
func order() {

	id := randomString(10)                       // 来个订单号
	callack := make(chan int)                    // 把返程的招呼打好
	t := task{id: uint32(id), callback: callack} // 订单起草完毕

	chTasks := chTaskList[id%taskNum] // 随机选择一个工厂,因为id都是随机生成的，取余数也是一个随机值
	chTasks <- t                      // 把订单交给小弟让他送送工厂去

	msg := <-callack // 拿到工厂编号
	_ = msg
	//fmt.Printf("给%v号工厂下了订单，%v号工厂拿到了订单\n", id%taskNum, msg)
	wg.Done()
}

// 工厂，接收小弟(chan)，返回工厂编号
func working(chTasks chan task, num int) {

	//fmt.Printf("第%v号工厂待命中...\n", num)
	wg.Done()
	for {
		t := <-chTasks    // 卸货
		id := t.id        // 订单编号
		_ = id            // 此处生产产品（业务逻辑）
		t.callback <- num // 返回工厂编号
	}

}

// 生成订单号
func randomString(n int) uint32 {
	var b []string
	for i := 0; i < n; i++ {
		num, _ := rand.Int(rand.Reader, big.NewInt(int64(len(arr))))
		// 1.将 *big.Int 转化为 int64
		// 2.将 int 64 转化为 int
		// 3.将 int 转化为 string
		b = append(b, strconv.Itoa(arr[int(num.Int64())]))
	}

	str := strings.Join(b, "") // 拼接字符串
	a, _ := strconv.Atoi(str)  // string 转 int
	yes := uint32(a)           // int 转 uint32
	return yes
}

结果：所有任务已执行完毕，用时3971800

 

测试机器是8核CPU