golang高并發(fā)限流操作 ping / telnet

import "github.com/sparrc/go-ping"
import "time"
func (p *Ping) doPing(timeout time.Duration, count int, ip string) (err error) {
 pinger, cmdErr := ping.NewPinger(ip)
 if cmdErr != nil {
  glog.Error("Failed to ping " + p.ipAddr)
  err = cmdErr
  return
 }
 pinger.Count = count
 pinger.Interval = time.Second
 pinger.Timeout = timeout
 // true的話，代表是標(biāo)準(zhǔn)的icmp包，false代表可以丟包類(lèi)似udp
 pinger.SetPrivileged(false)
 // 執(zhí)行
 pinger.Run() 
 // 獲取ping后的返回信息
 stats := pinger.Statistics() 
 //延遲
 latency = float64(stats.AvgRtt) 
 // 標(biāo)準(zhǔn)的往返總時(shí)間 
 jitter = float64(stats.StdDevRtt) 
 //丟包率 
 packetLoss = stats.PacketLoss 
 return
}

package main
import (
 "github.com/reiver/go-telnet"
)
func doTelnet(ip string, port int) {
 var caller telnet.Caller = telnet.StandardCaller
 address := ip + ":"+ strconv.Itoa(port)
 // DialToAndCall 檢查連通性并且調(diào)用
 telnet.DialToAndCall(address, caller)
 }
}

import "net"
func doTelnet(ip string, ports []string) map[string]string {
 // 檢查 emqx 1883, 8083, 8080, 18083 端口
 results := make(map[string]string)
 for _, port := range ports {
 address := net.JoinHostPort(ip, port)
 // 3 秒超時(shí)
 conn, err := net.DialTimeout("tcp", address, 3*time.Second)
 if err != nil {
 results[port] = "failed"
 } else {
 if conn != nil {
 results[port] = "success"
 _ = conn.Close()
 } else {
 results[port] = "failed"
 }
 }
 }
 return results
}

while read ip
do
 {
 doPing(ip)
 } 
done  ip.txt

import (
 "context"
 "fmt"
 "log"
 "time"
 "sync"
 "golang.org/x/time/rate"
)
func Limit(ips []string)([]string, []string, error) {
 //第一個(gè)參數(shù)是每秒鐘最大的并發(fā)數(shù)，第二個(gè)參數(shù)是桶的容量，第一次的時(shí)候每秒可執(zhí)行的數(shù)量就是桶的容量，建議這兩個(gè)值都寫(xiě)成一樣的
 r := rate.NewLimiter(10, 10)
 ctx := context.Background()
 
 wg := sync.WaitGroup{}
 wg.Add(len(ips))
 
 lock := sync.Mutex{}
 var success []string
 var fail []string
 
 defer wg.Done()
 for _,ip:=range ips{
 //每次消耗2個(gè)，放入一個(gè)，消耗完了還會(huì)放進(jìn)去，如果初始是5個(gè)，所以這段代碼再執(zhí)行到第4次的時(shí)候筒里面就空了，如果當(dāng)前不夠取兩個(gè)了，本次就不取，再放一個(gè)進(jìn)去，然后返回false
 err := r.WaitN(ctx, 2)
 if err != nil {
  log.Fatal(err)
 }
 go func(ip string) {
 defer func() {
 wg.Done()
 }()
 err := doPing(time.Second, 2, ip)
 lock.Lock()
 defer lock.Unlock()
 if err != nil {
 fail = append(fail, ip)
 return
 } else {
 success = append(success, ip)
 }
 }(ip)
 }
 // wait等待所有g(shù)o協(xié)程結(jié)束
 wg.wait()
 return success,fail,nil
}
func main() {
 ips := [2]string{"192.168.1.1","192.168.1.2"}
 success,fail,err := Limit(ips)
 if err != nil {
 fmt.Printf("ping error")
 }
}

func main() {
 go print() // 啟動(dòng)一個(gè)goroutine
 print()
}
func print() {
fmt.Println("*******************")
}

func main() {
 var channel chan string = make(chan string)
 go func(message string) {
 channel- message // 存消息
 }("Ping!")
 fmt.Println(-messages) // 取消息
}

channel := make(chan int, 3)
channel - 1
channel - 2
channel - 3
// 顯式關(guān)閉信道
close(channel)
for v := range channel {
 fmt.Println(v)
 // 如果現(xiàn)有數(shù)據(jù)量為0，跳出循環(huán)，與顯式關(guān)閉隧道效果一樣，選一個(gè)即可
 if len(ch) = 0 { 
 break
 }
}

// 創(chuàng)建一個(gè)計(jì)時(shí)信道
timeout := time.After(1 * time.Second) 
// 監(jiān)聽(tīng)3個(gè)信道的數(shù)據(jù)
select {
 case v1 := - c1: fmt.Printf("received %d from c1", v1)
 case v2 := - c2: fmt.Printf("received %d from c2", v2)
 case v3 := - c3: fmt.Printf("received %d from c3", v3)
 case - timeout: 
 is_timeout = true // 超時(shí)
 break
 }
}