深度探索Go语言：高效并发编程与实战案例
在现代软件开发中，高效的并发编程变得越来越重要。Go语言（通常称为Golang）作为一种设计用于可靠性和简单性的系统编程语言，提供了一种轻量级且易于使用的方式来进行并发操作。
Go语言中的goroutines和channels
Go语言引入了两种新的概念：goroutines和channels。Goroutines是轻量级线程，它们非常便宜，并且可以很容易地创建出来。而channels则是一种同步机制，可以用来安全地在不同的goroutine之间通信。
使用goroutines处理网络请求
一个常见的场景是使用多个 goroutine 来处理网络请求，以提高程序性能。当我们发送HTTP请求时，我们可以创建一个goroutine来异步获取数据，而不必阻塞主线程。这使得我们的应用程序能够同时处理多个任务，从而提高了响应时间。
package main
import (
"fmt"
"net/http"
)
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
go fetchData(r.URL.Path[1:], w)
})
fmt.Println("Server is listening on port 8080")
http.ListenAndServe(":8080", nil)
}
func fetchData(path string, w http.ResponseWriter) {
resp, err := http.Get("https://example.com/" + path)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
w.Write(body)
}
使用channels优化数据库查询
当我们需要执行数据库查询时，我们可能会遇到锁争用的问题，这些问题可以通过 channels 来解决。在下面的例子中，我们使用 channels 来避免直接访问同一资源的问题：
package main
import (
"database/sql"
"fmt"
log "github.com/sirupsen/logrus"
)
type QueryResult struct{}
var queryChannels = make(chan QueryResult, 10)
func dbQuery(id int64) (QueryResult, error) {
db := sql.Open("mysql", "user:password@tcp(localhost:3306)/dbname")
defer db.Close()
rows, err := db.Query("SELECT column FROM table WHERE id = ?", id)
if err != nil {
return QueryResult{}, err
}
var result QueryResult
for rows.Next() {
err = rows.Scan(&result.columnNameFromDbTable...)
if err != nil {
log.Errorf("Error scanning row: %v", err)
continue
}
queryChannels <- result // Send the query result to the channel.
}
return result,nil // Return a dummy value as we are sending results via channel.
}
func worker(id int64) chan bool {
go func() {
var ok bool
if _, ok = <-queryChannels; !ok { // Check if the channel has been closed.
log.Warnf("Worker %d exit due to receiving false from queryChannel.", id )
return
}
defer close(queryChannels)
for range time.NewTicker(time.Second).C {
select {
case res:=<-queryChannels:
fmt.Printf("\nWorker %d received data. Data is :%s\n",id,res.columnNameFromDbTable...)
default:
continue
}
}
}()
ch:=make(chan bool)
return ch
}
// This function will be called when all workers have finished their work.
func finishAllWorkers(channels []chan bool){
for _,ch:=range channels{
close(ch)// Close each of the worker's channels once they're done with their work.
<-ch// Wait until all workers have completed their tasks before continuing.
}
}
// Start multiple workers and wait for them to complete their tasks before exiting.
func main(){
numOfWorkers := 5
var wg sync.WaitGroup
queriesToRun := make([]int64,nrOfQueriesToRun)// Array of IDs that need to be processed by database queries
wg.Add(numOfWorkers)// Increment our WaitGroup counter by number of goroutines we want to start.
go func(){
finishAllWorkers(make([]chan bool,numOfWorkers))// Call this function in a separate goroutine so it doesn't block execution while waiting for other workers' completion signals. It creates an array of new channels and waits until they've all been closed (i.e., when all workers are done).
wg.Done()
}()
/*Start your application logic here*/
time.Sleep(time.Second*10)// Simulate some processing time
close(queriesToRunChanel)// Close any remaining open input channel after finishing up with your application logic.
wg.Wait()
}
这些示例展示了如何利用Go语言的特性进行高效的并发编程，同时保持代码简洁直观。这使得开发者能够更快地构建出性能卓越、可扩展性的应用程序。
