go code01

阅读更多

package pse

import (
	"sync"
	"time"
)

type (
	subscriber chan interface{} // 订阅者为一个管道
	topicFunc func(v interface{}) bool // 主题为一个过滤器
)

// 发布者对象
type Publisher struct {
	m sync.RWMutex // 读写锁
	buffer int // 订阅队列的缓存大小
	timeout time.Duration // 发布超时时间
	subscribers map[subscriber]topicFunc // 订阅者信息
}

// 构建一个发布者对象, 可以设置发布超时时间和缓存队列的长度
func NewPublisher(publishTimeout time.Duration, buffer int) *Publisher {
		return &Publisher{
				buffer: buffer,
				timeout: publishTimeout,
				subscribers: make(map[subscriber]topicFunc),
	}
}

// 添加一个新的订阅者，订阅全部主题
func (p *Publisher) Subscribe() chan interface{} {
	return p.SubscribeTopic(nil)
}

// 添加一个新的订阅者，订阅过滤器筛选后的主题
func (p *Publisher) SubscribeTopic(topic topicFunc) chan interface{} {
	ch := make(chan interface{}, p.buffer)
	p.m.Lock()
	p.subscribers[ch] = topic
	p.m.Unlock()
	return ch
}

// 退出订阅
func (p *Publisher) Evict(sub chan interface{}) {
	p.m.Lock()
	defer p.m.Unlock()
	delete(p.subscribers, sub)
	close(sub)
}

//发布一个主题
func (p *Publisher) Publish(v interface{}) {
	p.m.RLock()
	defer p.m.RUnlock()
	var wg sync.WaitGroup
	for sub, topic := range p.subscribers {
		wg.Add(1)
		go p.sendTopic(sub, topic, v, &wg)
	}
	wg.Wait()
}

// 关闭发布者对象，同时关闭所有的订阅者管道。
func (p *Publisher) Close() {
	p.m.Lock()
	defer p.m.Unlock()
	for sub := range p.subscribers {
		delete(p.subscribers, sub)
		close(sub)
	}
}

// 发送主题，可以容忍一定的超时
func (p *Publisher) sendTopic(
	sub subscriber, topic topicFunc, v interface{}, wg *sync.WaitGroup,
) {
	defer wg.Done()
	if topic != nil && !topic(v) {
		return
	}

	select {
		case sub <- v:
	    case <-time.After(p.timeout):
	}
}

/**********************************************/
package main

import (
	"fmt"
	"strings"
	"time"
	"./pse"
)

func main() {
	p := pubsub.NewPublisher(100*time.Millisecond, 10)
	defer p.Close()
	all := p.Subscribe()
	golang := p.SubscribeTopic(func(v interface{}) bool{
		if s, ok := v.(string); ok {
			return strings.Contains(s, "golang")
		}
		return false
	})

	p.Publish("hello, world!")
	p.Publish("hello, golang!")
	go func() {
		for msg := range all {
			fmt.Println("all:", msg)
		}
	}()

	go func() {
		for msg := range golang {
			fmt.Println("golang:", msg)
		}
	}()

	// 运行一定时间后退出
	time.Sleep(3 * time.Second)
}

//现在每个工作者并发体的创建、运行、暂停和退出都是在 main 函数的安全控制之
//下了

package main

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

func worker(wg *sync.WaitGroup, cannel chan bool) {
   defer wg.Done()
   for {
      select {
         default:
            fmt.Println("hello")
         case <-cannel:
            return
}
   }
}

func main() {
   cancel := make(chan bool)
   var wg sync.WaitGroup
   for i := 0; i < 10; i++ {
      //cancel <- false
wg.Add(1)
      go worker(&wg, cancel)
   }

   time.Sleep(time.Second)
   close(cancel)
   wg.Wait()
}

通常是最后一个
来传递错误信息。如果导致失败的原因只有一个，额外的返回值可以是一个布尔
值，通常被命名为ok。比如，当从一个 map 查询一个结果时，可以通过额外的布
尔值判断是否成功：
if v, ok := m["key"]; ok {
       return v
}