咖啡伴侣

呆在上海
posts - 163, comments - 156, trackbacks - 0, articles - 2

2013年11月20日

golang chan 超时

package main

import (
    "fmt"
    "time"
)

var ch chan int = make(chan int, 1)

func main() {
    go aaa()

    select {
    case <-ch: //拿到锁
        fmt.Println("call")
    case <-time.After(5 * time.Second): //超时5s
        fmt.Println("5 sec call")
    }
}

func aaa() {
    time.Sleep(time.Second * 3)
    ch <- 1
}

posted @ 2013-12-24 13:03 oathleo 阅读(7278) | 评论 (0) | 编辑 收藏

golang 之 接口

conn, err = ln.Accept()
go handleConnection(conn)
看到这里我曾经有个疑问，为什么不是  handleConnection(&conn) ?

下面这个例子解释这个问题

package main

import (
    "fmt"
)

type Interface interface {
    say() string
}

type Object struct {
}

func (this *Object) say() string {
    return "hello"
}

func do(i Interface) string {
    return i.say()
}

func main() {
    o := Object{}
    fmt.Println(do(&o))
    fmt.Printf("CCCCCCCCCCC:%T", o)
}

函数的参数以接口定义，编译器会自己判断参数是对象还是对象的指针
比如，say是指针上的方法，所以do只接受Object的指针做参数，do(o)是编译不过的

所以看到库里接口做参数类型定义的时候，可以简单认为，这个接口肯定是个对象指针（虽然也可以用对象，单估计没有哪个类库会用）

例如：
 conn, err = ln.Accept()
go handleConnection(conn)

这里conn是个接口，不需要 go handleConnection(&conn)

posted @ 2013-12-22 12:45 oathleo 阅读(4383) | 评论 (1) | 编辑 收藏

golang定时定点任务

package main

import (
    "fmt"
    "mag/common"
    "time"
)

func main() {
    c := make(chan bool, 10)

    tt := common.GetTodayGivenTime("161300")
    dd := common.SinceNow(tt)
    time.AfterFunc(dd, func() { //非阻塞
        //后续每24小时建立目录
        ticker24h := time.NewTicker(5 * time.Second)
        for {
            select {
            case <-ticker24h.C:
                fmt.Println("print")
            }
        }
    })

    <-c
}

posted @ 2013-12-19 16:15 oathleo 阅读(5359) | 评论 (0) | 编辑 收藏

golang append时slice len 和 cap

声明:
源slice= src
添加slice = app
结果slice=tar
append时
len tar === len src +   len app
1）如果len(src) + len(app) <= cap(src)    cap tar  =   cap(src)
2）否则 
      a) len(src) + len(app) > 2* cap(src)     cap tar  =   len(src) + len(app)
      b) cap(src) < len(src) + len(app) <= 2* cap(src)    cap tar = 2* cap(src)
    data := make([]int, 10, 20)
    data[0] = 1
    data[1] = 2

    dataappend := make([]int, 12, 30)//修改这个len 
    dataappend[0] = 1
    dataappend[1] = 2

    result := append(data, dataappend)

    result[0] = 99
    result[11] = 98

    fmt.Println("length:", len(data), "cap:", cap(data), ":", data)
    fmt.Println("result length:", len(result), "cap:", cap(result), ":", result)
    fmt.Println("length:", len(dataappend), "cap:", cap(dataappend), ":", dataappend)

posted @ 2013-11-20 18:48 oathleo 阅读(5248) | 评论 (1) | 编辑 收藏

golang slice分割和append copy还是引用

1.slice1:= slice[0:2]
引用，非复制，所以任何对slice1或slice的修改都会影响对方
data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
data1 := data[0:2]
data1[0] = 99
fmt.Println(data1)
fmt.Println(data)
[99 2]
[99 2 3 4 5 6 7 8 9 0]
2.append
append 比较特殊
声明:
源slice= src
添加slice = app
结果slice=tar
1）如果len(src) + len(app) <= cap(src)  src和tar 是指向同一数据引用 ，即修改src或tar，会影响对方
2）否则 tar 是copy的方式 src + app ，即修改src或tar，不会影响对方
无论哪种情况不会影响app，因为app都会用copy的方式进入tar
 
func test2() {
data := make([]int, 10, 20)
data[0] = 1
data[1] = 2
dataappend := make([]int, 10, 20)//len <=10 则  result[0] = 99 会 影响源Slice
dataappend[0] = 1
dataappend[1] = 2
result := append(data, dataappend...)
result[0] = 99
result[11] = 98
fmt.Println("length:", len(data), ":", data)
fmt.Println("length:", len(result), ":", result)
fmt.Println("length:", len(dataappend), ":", dataappend)
}

posted @ 2013-11-20 18:46 oathleo 阅读(6659) | 评论 (1) | 编辑 收藏