golang 读写锁 channel

---

//package main

//

//import (

// "fmt"

// "io/ioutil"

// "net/http"

// "net/url"

//)

//

//func main() {

//

// //demo1

// /*resp, err := http.Get("https://www.baidu.com/")

// defer resp.Body.Close()

// body,err := ioutil.ReadAll(resp.Body)

// fmt.Println(body,string(body),err )*/

//

// //demo2

// /* var buf io.Reader

//    resp, err := http.Post("https://sbx-oms.eminxing.com/default/index/new-login", "text/json;charset=UTF-8", buf)

//    defer resp.Body.Close()

//    body,err:= ioutil.ReadAll(resp.Body)

//    fmt.Println(string(body),err)*/

//

// //demo3

// resp, _ := http.PostForm("https://sbx-oms.eminxing.com/default/index/new-login",

//    url.Values{"userCode": {"zhuoli"}, "password": {"Td147852"}})

//

// str_byte ,_ := ioutil.ReadAll(resp.Body)

// fmt.Println(string(str_byte))

//

//}

//package main

//

//import (

// "log"

// "os/exec"

//

// "github.com/fsnotify/fsnotify"

//)

//

//func main() {

// watcher, err := fsnotify.NewWatcher()

// if err != nil {

//    log.Fatal(err)

// }

// defer watcher.Close()

//

// done := make(chan bool)

// go func() {

//    for {

//       select {

//       case event := <-watcher.Events:

//          log.Println("event:", event)

//          if event.Op&fsnotify.Write == fsnotify.Write {

//             log.Println("modified file:", event.Name)

//          }

//          nginx()

//       case err := <-watcher.Errors:

//          log.Println("error:", err)

//       }

//    }

// }()

//

// err = watcher.Add("/path/to/file1")

// if err != nil {

//    log.Fatal(err)

// }

// err = watcher.Add("/path/to/file2")//也可以监听文件夹

// if err != nil {

//    log.Fatal(err)

// }

// <-done

//}

//

//func nginx() {

// cmd := exec.Command("/usr/local/bin/lunchy", "restart", "nginx") //重启命令根据自己的需要自行调整

// cmd.Run()

//}

//package main

//

//import (

// "fmt"

// "os/user"

//)

//

//func main() {

// user.LookupId("S-1-5-21-1347689362-1153694367-876260375-500")

//

//

// u,error := user.Current()

// if error!=nil{

//    fmt.Println(error)

// }

//

// fmt.Println(u.Uid)

// fmt.Println(u.Name)

// fmt.Println(u.Gid)

// fmt.Println(u.HomeDir)

// fmt.Println(u.Username)

//}

package main

import (

   "fmt"

   "log"

   "os"

   "reflect"

   "strconv"

   "strings"

   "sync"

   "testing"

   "time"

)

func main1() {

   r := strings.NewReader("sdfsdf")

   b := make([]byte, r.Size())

   n, err := r.Read(b)

   if err != nil {

      fmt.Println("未读取到", err)

      return

   }

   fmt.Println("读取长度", n)

   fmt.Println("流中数据", string(b))

}

type People struct {

   name     string `xmla:"name"`

   Address  string `xmsa:"address"`

   Address2 string `xmsa:"Address2"`

}

func (this People) Te() {

   fmt.Println("Teeeeeeeeeeeeeeee", this)

}

//todo

func TestAbc(t *testing.T) {

   //a:=1.5;

   //fmt.Println(reflect.TypeOf(a))

   //fmt.Println(reflect.ValueOf(a))

   /*peo:=People{"small","北京"}

   v := reflect.TypeOf(peo)

   fmt.Println(v.NumField())

   fmt.Println(v.FieldByIndex([]int{0} ))

   conten := "name"

   re,_ := v.FieldByName(conten)

   fmt.Printf("%#v",re)*/

   /*conten := "name"

   peo := new(People)

   v:= reflect.ValueOf(peo).Elem()

   fmt.Println(v.FieldByName(conten).CanSet())

   v.FieldByName(conten).SetString("ddddddddddd");

   fmt.Println(peo)*/

   //conten := "name"

   //peo := new(People)

   v := reflect.TypeOf(People{})

   //me , _ := v.MethodByName("Te")

   fmt.Println(v.NumMethod())

   fmt.Println(v.NumMethod())

   //re,_ := v.FieldByName(conten)

   fmt.Println(v.NumField())

   re := v.FieldByIndex([]int{0})

   fmt.Println(re.Tag.Get("xmla"))

   //v.FieldByName(conten).SetString("ddddddddddd");

   //fmt.Println(peo)

   //peo.address = "sdf"

   //fmt.Println(peo)

   //a := "name"

   //peo := Perple{"sdf"}

   //fmt.Println(peo.)

}

//todo apend前后追加

func TestAbc2(T *testing.T) {

   abc := []int{1, 2, 3}

   a := []int{111}

   b := append(abc, 11, 12)

   b = append(a, b...)

   fmt.Println(b[:])

}

//todo *日志

func TestLog(T *testing.T) {

   //log.Println("打印日志信息")

   //log.Panic("panic")

   //log.Fatal("Fatal")

   f, _ := os.OpenFile("./golog.log", os.O_APPEND|os.O_CREATE, 0777)

   logger := log.New(f, "[info]", log.Ldate|log.Ltime)

   logger.Println("sdfsdfdsf")

   logger.Panicln("sdfsdfdsf")

}

//todo time

func TestTime(t *testing.T) {

   fmt.Println("begin")

   time.AfterFunc(3e9, func() {

      fmt.Println("ing")

   })

   time.Sleep(5e9)

   fmt.Println("ok")

   //fmt.Println("111")

   //time.Sleep(2*time.Second)

   //fmt.Println("222")

   //fmt.Println("222")

}

//todo goroutine

func TestGoroutine(t *testing.T) {

   for i := 0; i < 5; i++ {

      go demo(i)

   }

}

func demo(count int) {

   for i := 0; i < 100; i++ {

      fmt.Println(count, ":", i)

   }

   time.Sleep(3e9)

}

//todo WaitGroup

func TestWaitGoroutine(t *testing.T) {

   var wg sync.WaitGroup

   wg.Add(5)

   for i := 0; i < 5; i++ {

      go func(i int) {

         fmt.Println("no ", i)

         wg.Done()

      }(i)

   }

   wg.Wait()

}

//todo 互斥锁 Mutex  go run -race

func TestChan(t *testing.T) {

   var wg sync.WaitGroup

   var m sync.Mutex

   wg.Add(11)

   num := 100

   for i := 0; i < 11; i++ {

      go func() {

         m.Lock()

         for i := 0; i < 10; i++ {

            num = num - 1

         }

         m.Unlock()

         wg.Done()

      }()

   }

   wg.Wait()

   fmt.Println(num)

}

//todo 读写锁

func TestRwMutex(t *testing.T) {

   var rwm sync.RWMutex

   m := make(map[string]string)

   var wg sync.WaitGroup

   wg.Add(10)

   for i := 0; i < 10; i++ {

      go func(j int) {

         rwm.Lock() //读写锁

         m["key"+strconv.Itoa(j)] = "value" + strconv.Itoa(j)

         fmt.Println(m)

         rwm.Unlock()

         wg.Done()

      }(i)

   }

   wg.Wait()

   fmt.Println("Success")

}

func TestChannel(t *testing.T) {

   ch := make(chan int)

   go func() {

      fmt.Println("go ing")

      time.Sleep(3e9)

      fmt.Println("end")

      ch <- 998

   }()

   a := <-ch

   fmt.Println(a)

   fmt.Println("end all")

}

func TestChannel2(t *testing.T) {

   ch1 := make(chan string)

   ch2 := make(chan int)

   go func() {

      ch1 <- "go1"

      ch2 <- 1

   }()

   go func() {

      content := <-ch1

      fmt.Println("取除数据 成功", content)

      ch2 <- 2

   }()

   <-ch2

   <-ch2

   fmt.Println("end")

}

func TestSelect(t *testing.T) {

   expr := 1

   switch expr {

   case 1:

      fmt.Println(1)

   case 2:

      fmt.Println(2)

   }

   ch1 := make(chan int, 1)

   ch2 := make(chan string, 1)

   //ch1<-11

   //ch2<-"smallming"

   select {

   case al := <-ch1:

      fmt.Println(al)

   case a2 := <-ch2:

      fmt.Println(a2)

   default:

      fmt.Println(111)

   }

}

func TestSelect2(t *testing.T) {

   expr := 1

   switch expr {

   case 1:

      fmt.Println(1)

   case 2:

      fmt.Println(2)

   }

   ch1 := make(chan int, 1)

   ch2 := make(chan string, 1)

   //ch1<-11

   //ch2<-"smallming"

   select {

   case al := <-ch1:

      fmt.Println(al)

   case a2 := <-ch2:

      fmt.Println(a2)

   case <-time.After(time.Second * 3)://设置了default  超时将会失效

      fmt.Println(111)

   //default:

   // fmt.Println(22)

   }

}

func TestChannel3(t *testing.T) {

   ch := make(chan int)

   for i := 0; i < 10; i++ {

      go func(j int) {

         ch <- j

      }(i)

   }

   for {

      select {

      case a := <-ch:

         fmt.Println(a)

      //case <-time.After(time.Second * 3): //设置了default  超时将会失效

      // fmt.Println(111)

      default:

      }

   }

}

//todo 流处理

//var (

// deviceID int

// err      error

// webcam   *gocv.VideoCapture

// stream   *mjpeg.Stream

//)

//

//func main1() {

//

//

// // parse args

// deviceID := 0

// host := ":8554"

//

// // open webcam

// webcam, err = gocv.OpenVideoCapture(deviceID)

// if err != nil {

//    fmt.Printf("Error opening capture device: %v\n", deviceID)

//    return

// }

// defer webcam.Close()

//

// // create the mjpeg stream

// stream = mjpeg.NewStream()

//

// // start capturing

// go mjpegCapture()

//

// fmt.Println("Capturing. Point your browser to " + host)

//

// // start http server

// http.Handle("/", stream)

// log.Fatal(http.ListenAndServe(host, nil))

//}

//

//func mjpegCapture() {

// img := gocv.NewMat()

// defer img.Close()

//

// for {

//    if ok := webcam.Read(&img); !ok {

//       fmt.Printf("Device closed: %v\n", deviceID)

//       return

//    }

//    if img.Empty() {

//       continue

//    }

//

//    buf, _ := gocv.IMEncode(".jpg", img)

//    stream.UpdateJPEG(buf)

// }

//}