使用golang的timer
定時任務
func demo(input chan interface{}) {
t1 := time.NewTimer(time.Second * 5)
t2 := time.NewTimer(time.Second * 10)
for {
select {
case msg <- input:
println(msg)
case <-t1.C:
println("5s timer")
t1.Reset(time.Second * 5)
case <-t2.C:
println("10s timer")
t2.Reset(time.Second * 10)
}
}
}
斷續器
func main(){
ticker := time.NewTicker(time.Second)
for t := range ticker.C {
fmt.Println("ticker", t)
}
}
超時
func main(){
ch1 := make(chan int, 1)
ch2 := make(chan int, 1)
select {
case e1 := <-ch1:
//如果ch1通道成功讀取數據，則執行該case處理語句
fmt.Printf("1th case is selected. e1=%v",e1)
case e2 := <-ch2:
//如果ch2通道成功讀取數據，則執行該case處理語句
fmt.Printf("2th case is selected. e2=%v",e2)
case <- time.After(2 * time.Second):
fmt.Println("Timed out")
}
}
自定義定時器
func main(){
var t *time.Timer
f := func(){
fmt.Printf("Expiration time : %v.\n", time.Now())
fmt.Printf("C`s len: %d\n", len(t.C))
}
t = time.AfterFunc(1*time.Second, f)
//讓當前Goroutine 睡眠2s，確保大于內容的完整
//這樣做原因是，time.AfterFunc的調用不會被阻塞。它會以一部的方式在到期事件來臨執行我們自定義函數f。
time.Sleep(2 * time.Second)
}
使用時間控制停止ticker
func main(){
//初始化斷續器,間隔2s
var ticker *time.Ticker = time.NewTicker(1 * time.Second)
go func() {
for t := range ticker.C {
fmt.Println("Tick at", t)
}
}()
time.Sleep(time.Second * 5) //阻塞，則執行次數為sleep的休眠時間/ticker的時間
ticker.Stop() //停止ticker
fmt.Println("Ticker stopped")
}
并發讀取文件夾所有文件的長度（使用通道）
func test1() {
// 遍歷文件夾，獲取文件名
dir := "./db"
paths, err := ioutil.ReadDir(dir)
check(err)
var files []string
for _, path := range paths {
if !path.IsDir() {
files = append(files, path.Name())
}
}
type FileInfo struct {
FileName string
Len int
Err error
}
way := make(chan FileInfo, 100)
for _, file := range files {
go func(fileName string) {
content, err := ioutil.ReadFile(fmt.Sprintf("%s/%s", dir, fileName))
// 無論對錯，都交給通道收取方
way <- FileInfo{
FileName: fileName,
Len: len(content),
Err: err,
}
}(file)
}
// 我們知道需要從通道中取多少條數據
for i := 0; i < len(files); i++ {
fileInfo := <-way
if fileInfo.Err != nil {
fmt.Printf("[err] file:%s, err: %s \n", fileInfo.FileName, fileInfo.Err.Error())
return
}
fmt.Printf("file:%s, len: %d \n", fileInfo.FileName, fileInfo.Len)
}
}
并發讀取文件夾所有文件的長度（使用sync.WaitGroup）
這個使用的其實就是計數器的道理
func test1() {
dir := "./db"
paths, err := ioutil.ReadDir(dir)
check(err)
var files []string
for _, path := range paths {
if !path.IsDir() {
files = append(files, path.Name())
}
}
// sizes用來計算總長度和阻塞直至所有goroutine走完
sizes := make(chan int64)
// 計數器
var wg sync.WaitGroup
for _, file := range files {
wg.Add(1)
go func(fileName string) {
defer wg.Done()
fileInfo, _ := os.Stat(fmt.Sprintf("%s/%s", dir, fileName))
sizes <- fileInfo.Size()
}(file)
}
go func() {
wg.Wait()
close(sizes)
}()
var total int64
for size := range sizes {
fmt.Printf("size:%d\n", size)
total += size
}
fmt.Printf("total size: %d\n", total)
}
令牌-另一種信號計數器
func check(err error) {
if err != nil {
panic(err)
}
}
func main() {
// 鏈接列表
workList := make(chan []string)
// 存儲已經處理的鏈接，使用map是為了去重
seen := make(map[string]bool)
// n是為了保證爬蟲一直爬
n := 1
// 初始化
go func() { workList <- []string{"http://www.lxweimin.com"} }()
for i := n; i > 0; i++ {
list := <-workList
for _, link := range list {
if !seen[link] {
seen[link] = true
n++
go func(link string) {
workList <- crawl(link)
}(link)
}
}
}
}
var tokens = make(chan struct{}, 20)
// 獲取網頁的鏈接 通過令牌
func crawl(url string) (list []string) {
fmt.Println(url)
tokens <- struct{}{}
list, err := Extract(url)
<-tokens
if err != nil {
log.Print(err)
return
}
return
}
// 獲取網頁的鏈接
func Extract(url string) (list []string, err error) {
resp, err := http.Get(url)
if err != nil {
return
}
if resp.StatusCode != http.StatusOK {
resp.Body.Close()
return nil, fmt.Errorf("getting %s, err %s", url, err.Error())
}
doc, err := html.Parse(resp.Body)
resp.Body.Close()
if err != nil {
return nil, fmt.Errorf("parsing %s as HTML, err %s", url, err.Error())
}
visitNode := func(n *html.Node) {
if n.Type == html.ElementNode && n.Data == "a" {
for _, a := range n.Attr {
if a.Key != "href" {
continue
}
link, err := resp.Request.URL.Parse(a.Val)
if err != nil {
continue
}
list = append(list, link.String())
}
}
}
// 將函數作為參數傳入（匿名函數）
forEachNode(doc, visitNode, nil)
return
}
func forEachNode(n *html.Node, pre, next func(node *html.Node)) {
if pre != nil {
pre(n)
}
for n := n.FirstChild; n != nil; n = n.NextSibling {
forEachNode(n, pre, next)
}
if next != nil {
next(n)
}
}
