鍍金池/ 問答/ GO問答
伐木累 回答

你這個寫法都錯誤了，代碼注釋地方。

package main

import (
    "fmt"
    "time"
    "net"
)

func main() {
    addr := "127.0.0.1:8999"
    go func() {
        tcpaddr, err := net.ResolveTCPAddr("tcp4", addr)
        if err != nil {
            panic(err)
        }
        listen, err := net.ListenTCP("tcp", tcpaddr)
        if err != nil {
            panic(err)
        }
        for  {
            if conn, err := listen.Accept(); err != nil {
                panic(err)
            } else if conn != nil {
                go func(conn net.Conn) {
                    buffer := make([]byte, 1024)
                    n, err := conn.Read(buffer)
                    if err != nil {
                        fmt.Println(err)
                    } else {
                        fmt.Println(">", string(buffer[0 : n]))
                    }
                    conn.Close()// 
                }(conn)
            }
        }
    }()
    time.Sleep(time.Second)
    // Client
    if conn, err := net.Dial("tcp", addr); err == nil {
        for i := 0; i < 2; i++ {
            _, err := conn.Write([]byte("hello"))
            if err != nil {
                fmt.Println(err)
                conn.Close()
                break
            } else {
                fmt.Println("ok")
            }
            // sleep 10 seconds and re-send
            time.Sleep(10*time.Second)
        }
    } else {
        panic(err)
    }
}
尐飯團 回答
  1. 保證數(shù)據(jù)庫穩(wěn)定（連接數(shù)被池上線限制了，數(shù)據(jù)庫不會掛）
  2. 盡量保證應(yīng)用穩(wěn)定（池滿了就新建，應(yīng)用不會等待，但是如果連接數(shù)過多，數(shù)據(jù)庫可能掛， 從而導(dǎo)致應(yīng)用掛）
蟲児飛 回答 
package main

import (
    "fmt"
    "net/http"
    "log"
    "time"
)


func handler(res http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(res, "<body>")
    for i := 0; i < 1000; i++ {
        fmt.Fprint(res, "<script>document.body.innerHTML = ''</script>")
        fmt.Fprintf(res, "%d", i)
        if f, ok := res.(http.Flusher); ok {
            f.Flush()
        } else {
            log.Println("Damn, no flush");
        }
        time.Sleep(1000 * time.Millisecond)
    }

    fmt.Fprintln(res, "</body>")
}

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}
檸檬藍 回答

當(dāng)所有的進程或線程都在等待資源釋放，而資源又釋放不了才會發(fā)生死鎖。

在這里main沒等待其它goroutine，自己先跑完了， 所以沒有數(shù)據(jù)流入ch，一共執(zhí)行了一個main, 并且沒有發(fā)生阻塞，所以沒有死鎖, 將代碼改成：

package main

import "sync"

func main() {
    ch1 := make(chan int)

    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        ch1 <- 1
        wg.Done()
    }()

    wg.Wait()
    // <-ch1
}

就會發(fā)生死鎖

不將就 回答

知道原因了，是go的slice的問題，參考個問題：
https://www.zhihu.com/questio...

根據(jù)上面的問答，得出一個理解和一個結(jié)論

理解：
slice或者數(shù)組，其子項的內(nèi)存地址必定是連續(xù)的。slice的長度和容量是兩個概念，長度是slice中有多少個值，容量是slice中最多能存多少個值。當(dāng)slice要增加子項時，總長度不能超過容量。

結(jié)論：
append會判斷原slice容量夠不夠，不夠則創(chuàng)建一個容量為原來的兩倍的新slice，并給新slice添加元素，如果夠則直接改變原slice未使用的第一個內(nèi)存地址的值為新元素。

由結(jié)論猜想出的一種bug：
有一個slice：a，容量為4，長度為3。把a用作append的第一個參數(shù)，返回值賦予給一些新slice，則這些新slice每個子項的內(nèi)存地址都是一一相等的，意味著改變了任何一個slice的任意一個值，其它slice對應(yīng)的值也會跟著變

show you the code


a := make([]int,3,4)
a[0] = 0
a[1] = 1
a[2] = 2
b := append(a,10)
c := append(a,100)
c[0] = 101

fmt.Println(&a[0],&b[0],&c[0]) //4 4 0xc0423eb500 0xc0423eb500 0xc0423eb500
fmt.Println(a[0],b[0],c[0]) //101 101 101
fmt.Println(b[3],c[3]) //100 100
司令 回答

徹底卸載（若你是Windows, 刪除C:\Users\當(dāng)前用戶\.vscode文件夾)，然后重新安裝。

貓小柒 回答

total小寫的，不可導(dǎo)出，多看看文檔吧

笑忘初 回答

一是存指針修改方便，直接使用map[0]的語法修改即可，不然就只能用中間變量整個struct重新賦值。
二是如果你的struct內(nèi)容太多，建議map存指針，避免取用的時候反復(fù)拷貝。即使map[0]這種取法取出來也只是原struct的拷貝。

糖豆豆 回答

Where("(mobile = ? or email = ?) and status <= ? ","18800000000", "test@test.com",1)

真難過 回答

是博文有誤，LDFLAGS的-lxxx不應(yīng)該有lib前綴,我已重新整理https://github.com/meilihao/t...

離殤 回答

beego的httplib組件個人感覺還不錯。

她愚我 回答

1.如果有固定位數(shù)，并且不太多的話，你可以先把所有滿足的結(jié)果列舉出來，存在一個數(shù)組里，然后用需要判斷的變量與數(shù)組里的每一項比較。
2.如果不想列舉的話，臥槽，兄弟你這規(guī)則有點奇怪啊，什么鬼都能叫順子嗎~~

愛是癌 回答

執(zhí)行順序從左到右，但左邊被賦值的變量在表達式的下一行才生效。

即 a, b = b, a+1 可理解成

temp_a = a
a = b
b = temp_a + 1

更多例子 https://golang.org/ref/spec#A...

a, b = b, a  // exchange a and b

x := []int{1, 2, 3}
i := 0
i, x[i] = 1, 2  // set i = 1, x[0] = 2

i = 0
x[i], i = 2, 1  // set x[0] = 2, i = 1

x[0], x[0] = 1, 2  // set x[0] = 1, then x[0] = 2 (so x[0] == 2 at end)

x[1], x[3] = 4, 5  // set x[1] = 4, then panic setting x[3] = 5.

type Point struct { x, y int }
var p *Point
x[2], p.x = 6, 7  // set x[2] = 6, then panic setting p.x = 7

i = 2
x = []int{3, 5, 7}
for i, x[i] = range x {  // set i, x[2] = 0, x[0]
    break
}
// after this loop, i == 0 and x == []int{3, 5, 3}
夏夕 回答

goroutine池很有必要，可以看看gf框架實現(xiàn)的grpool: http://gf.johng.cn/504458

在高并發(fā)下grpool的性能比原生的goroutine高出幾倍到數(shù)百倍，具體看下測試報告以及測試代碼。grpool支持工作線程數(shù)量限制，底層是使用channel來實現(xiàn)的。我覺得數(shù)量限不限制主要還是看業(yè)務(wù)場景以及硬件性能，默認(rèn)情況下一般不需要限制。

妖妖 回答

第一種方法是最好的也是實踐中最實用的。
proto寫的多的話，你會發(fā)現(xiàn)，proto中 message數(shù)據(jù)結(jié)構(gòu)定義的會越來越多，所以，針對同一類型的request message，盡量可以定義的大而全，需要哪些字段就給哪些字段賦值，不需要不賦值即可，不賦值的話傳輸沒有任何消費。
還有就是 什么層做什么事情，不要各種耦合，會很亂的。
不要覺得第一種會啰嗦，其實一點都不浪費也不臃腫的。

情殺 回答 
package main

import (
    "container/list"
    "fmt"
)

func main() {
    l1 := list.New()
    l1.PushBack(1)
    fmt.Println(l1.Back().Value)

    l2 := *l1
    l2.PushBack(2)
    fmt.Println(l1.Back().Value, l2.Back().Value)
}

輸出

1
2 1
首頁 上一頁 1 2 3 4 5 6 7 8 下一頁 尾頁