golang 簡單連接池

 

package main
 
import (
	"fmt"
	"time"
)
 
/* 有關Task任務相關定義及操作 */
//定義任務Task類型,每一個任務Task都可以抽象成一個函數
type Task struct {
	f func() error //一個無參的函數類型
}
 
//通過NewTask來創建一個Task
func NewTask(f func() error) *Task {
	t := Task{
		f: f,
	}
	return &t
}
 
//執行Task任務的方法
func (t *Task) Execute() {
	t.f() //調用任務所綁定的函數
}
 
/* 有關協程池的定義及操作 */
//定義池類型
type Pool struct {
	EntryChannel chan *Task //對外接收Task的入口
	worker_num   int        //協程池最大worker數量,限定Goroutine的個數
	JobsChannel  chan *Task //協程池內部的任務就緒隊列
}
 
//創建一個協程池
func NewPool(cap int) *Pool {
	p := Pool{
		EntryChannel: make(chan *Task),
		worker_num:   cap,
		JobsChannel:  make(chan *Task),
	}
	return &p
}
 
//協程池創建一個worker並且開始工作
func (p *Pool) worker(work_ID int) {
	//worker不斷的從JobsChannel內部任務隊列中拿任務
	for task := range p.JobsChannel {
		//如果拿到任務,則執行task任務
		task.Execute()
		fmt.Println("worker ID ", work_ID, " 執行完畢任務")
	}
}
 
//讓協程池Pool開始工作
func (p *Pool) Run() {
	//1,首先根據協程池的worker數量限定,開啓固定數量的Worker,
	//  每一個Worker用一個Goroutine承載
	for i := 0; i < p.worker_num; i++ {
		fmt.Println("開啓固定數量的Worker:", i)
		go p.worker(i)
	}
 
	//2, 從EntryChannel協程池入口取外界傳遞過來的任務
	//   並且將任務送進JobsChannel中
	for task := range p.EntryChannel {
		p.JobsChannel <- task
	}
 
	//3, 執行完畢需要關閉JobsChannel
	close(p.JobsChannel)
	fmt.Println("執行完畢需要關閉JobsChannel")
 
	//4, 執行完畢需要關閉EntryChannel
	close(p.EntryChannel)
	fmt.Println("執行完畢需要關閉EntryChannel")
}
 
//主函數
func main() {
	//創建一個Task
	t := NewTask(func() error {
		fmt.Println("創建一個Task:", time.Now().Format("2006-01-02 15:04:05"))
		return nil
	})
 
	//創建一個協程池,最大開啓3個協程worker
	p := NewPool(3)
 
	//開一個協程 不斷的向 Pool 輸送打印一條時間的task任務
	go func() {
		for {
			p.EntryChannel <- t
		}
	}()
 
	//啓動協程池p
	p.Run()
}

　　

動態版（待完善）

package main

import (
	"fmt"
	"sync"
	"time"
)

type Task struct {
	f func()
}

func NewTask(f func()) Task {
	return Task{
		f: f,
	}
}

type Work struct {
	status    int
	closeChan chan struct{}
}

func NewWork() *Work {
	return &Work{
		status:    0,
		closeChan: make(chan struct{}),
	}
}

func (w *Work) work(job chan Task, wg *sync.WaitGroup) {

	ticker := time.NewTicker(3 * time.Second)
	//定時查詢自己
	for {
		select {
		case <-w.closeChan:
			//判斷當前最小值
			wg.Done()
			break
		case task := <-job:
			w.status = 1
			task.f()
		case <-ticker.C:
			w.status = 0
			ticker.Reset(3 * time.Second)
		}
	}
}

type Pool struct {
	Max     int
	Min     int
	JobChan chan Task
	Workers []*Work
}

func NewPoll(max, min int) *Pool {
	return &Pool{
		Max:     max,
		Min:     min,
		JobChan: make(chan Task),
		Workers: make([]*Work, 0),
	}
}

func (p *Pool) Submit(t Task) {
	p.JobChan <- t
}

func (p *Pool) Run() {

	var wg sync.WaitGroup

	for i := 0; i < p.Min; i++ {
		// go NewWork().work(p.JobChan, &wg)
		p.Workers = append(p.Workers, NewWork())
	}

	p.Schdule(&wg)
	fmt.Println("11111111")
	p.Watch(&wg)
	wg.Wait()
}

func (p *Pool) Schdule(wg *sync.WaitGroup) {
	for j := 0; j < len(p.Workers); j++ {
		if p.Workers[j].status == 0 {
			wg.Add(1)
			go p.Workers[j].work(p.JobChan, wg)
		}
	}
}

// 監控worker
func (p *Pool) Watch(wg *sync.WaitGroup) {
	fmt.Println("watch")
	//TODO 監控work數 小於最大數，且持續5秒沒完成，則創建新worker
	for {
		ticker := time.NewTicker(5 * time.Second)
		select {
		case <-ticker.C:
			fmt.Println("timeeeeeeeeeeee")
			for _, v := range p.Workers {
				if v.status == 0 && len(p.Workers) > p.Min {
					//關閉worker
					close(v.closeChan)
				}
			}

			if len(p.Workers) < p.Max && len(p.Workers) >= p.Min {
				p.Workers = append(p.Workers, NewWork())
				p.Schdule(wg)
			}
			ticker.Reset(5 * time.Second)
		}
	}
}

func main() {
	p := NewPoll(10, 3)

	go func() {
		for {
			p.Submit(NewTask(func() {
				// fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
			}))
		}
	}()

	go func() {
		for {
			time.Sleep(time.Second)
			fmt.Println(len(p.Workers))
		}

	}()

	p.Run()
}

　　

 

參考鏈接：https://blog.csdn.net/finghting321/article/details/106492915/