golang 一个Hello World Golang服务示例。

Posted 2021-05-24

package main
 
import (
   "fmt"
   "log"
   "net/http"
)
 
func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
      fmt.Fprintf(w, "Hello!")
    })
 
    log.Println("Listening on 8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

[golang]定时器

定时器

go中time包中定时器主要有三种，Sleep、Timer、Ticker。下面逐一来进行说明。

1: Sleep

可以通过Sleep进行指定时间的睡眠。

func Sleep(d Duration)

例如延迟三秒中后输出hello,world。

time.Sleep(time.Second * 3)
fmt.Println("hello,world")

2:Timer

Timer是一个定时器，代表未来的一个单一事件，你可以告诉timer你要等待多长时间。

type Timer struct {
   C <-chan Time
   r runtimeTimer
}

它提供一个channel，在定时时间到达之前，没有数据写入timer.C会一直阻塞。直到定时时间到，向channel写入值，阻塞解除，可以从中读取数据。

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个定时器
    timer1 := time.NewTimer(time.Second * 3) // 当三秒后定时器会向自己的c字节发送一个time.Time类型的元素值
    fmt.Println("现在的时间:",time.Now())


    t := <- timer1.C
    fmt.Println("接收到的时间:",t)
}

输出的结果:

现在的时间: 2020-03-21 10:30:22.064938 +0800 CST m=+0.000127008
接收到的时间: 2020-03-21 10:30:25.069487 +0800 CST m=+3.004669121

Process finished with exit code 0

如果只是单纯的想要睡眠延迟，建议使用time.Sleep()。

在其中，还有一个time.After()函数，作用是指定时间之后向返回的chan中写入时间。

func After(d Duration) <-chan Time {
    return NewTimer(d).C
}

从上面的源码中可以看出，time.After()是通过NewTimer实现。如果想要让效率更高一点，可以使用NewTimer。

示例：

t := time.After(time.Second*2)

fmt.Println(<-t) // 会在2秒钟之后得到结果

通常来说，可以通过select 和 time.Affer的结合，实现超时控制。

package main

import (
    "time"
    "fmt"
)

func main() {
    ch := make(chan string)

    go func() {
        time.Sleep(time.Second * 2)

        ch <- "result"
    }()

    select {
    case res := <-ch:
        fmt.Println(res)
    case <-time.After(time.Second * 1):
        fmt.Println("timeout")
    }
}

定时器整理：

• 实现延迟功能。

  • <-time.After(2 * time.Second) // 定时2s，阻塞2s,2s后产生一个事件，往channel写内容

  • time.Sleep(2 * time.Second) // 睡眠延迟2秒

  • timer := time.NewTimer(2 * time.Second) // 延迟两秒 写入时间
    <- timer.C

• 停止定时器

  • timer := time.NewTimer(3 * time.Second)
    go func() {
      <-timer.C
      fmt.Println("子协程可以打印了，因为定时器的时间到")
    }()
    timer.Stop() //停止定时器
    
    for {
      ；
    }

• 定时器重置

  • timer := time.NewTimer(3 * time.Second)
    ok := timer.Reset(1 * time.Second) //重新设置为1s
    fmt.Println("ok = ", ok)
    <-timer.C
    fmt.Println("时间到")

3: Ticker

Ticker是一个周期触发定时的计时器，它会按照一个时间间隔往channel发送系统当前时间，而channel的接收者可以以固定的时间间隔从channel中读取事件。

type Ticker struct {
  C <-chan Time     // The channel on which the ticks are delivered.
  r runtimeTimer
}

例如:

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个周期定时ticker
    ticker := time.NewTicker(time.Second * 3)


    for {
        t := <-ticker.C

        fmt.Println(t)
    }
}

上面的代码中，每隔三秒就能获取一个时间。