golang并发任务

golang是一门支持并发编程的语言，它提供了丰富的特性和库来简化并发任务的处理。并发任务是指在同一时间内执行多个任务，这些任务可以在不同的线程或协程中同时运行。在本文中，我们将讨论如何使用golang进行并发任务的处理。

goroutine：轻量级的线程

在golang中，可以使用goroutine来实现并发任务。goroutine有点类似于线程，但是启动和销毁的代价比线程小得多。使用goroutine只需使用go关键字即可启动一个新的协程，在协程中执行需要并发处理的任务。

下面是一个使用goroutine处理并发任务的简单例子：

func main() {
    go task1()
    go task2()
    time.Sleep(time.Second)
}

func task1() {
    fmt.Println("Task 1")
}

func task2() {
    fmt.Println("Task 2")
}

在上面的例子中，我们使用go关键字分别启动了task1和task2两个协程，并通过time.Sleep函数等待协程完成。在执行过程中，task1和task2函数可以同时运行，实现了任务的并发处理。

通道：协程间的通信

在并发任务中，协程之间往往需要进行通信，以获得共享状态或传递数据。golang提供了通道（channel）来实现协程间的通信。通道是一种特殊的数据类型，可以用于协程之间的数据传输。

下面是一个使用通道进行协程间通信的例子：

func main() {
    ch := make(chan string)
    go send(ch, "Hello")
    msg := <-ch
    fmt.Println(msg)
}

func send(ch chan<- string, msg string) {
    ch <- msg
}

在上面的例子中，我们首先使用make函数创建了一个通道ch。然后，启动了一个协程send，通过通道向主协程发送消息。主协程通过<-操作符从通道中接收消息，并将接收到的消息打印出来。

互斥锁：保护共享资源

在并发任务中，如果多个协程同时访问和修改同一个共享资源时，很容易出现竞态条件（race condition）。为了避免竞态条件，golang提供了互斥锁（mutex）来保护共享资源。

下面是一个使用互斥锁保护共享资源的例子：

import (
    "sync"
    "time"
)

type Counter struct {
    count int
    mutex sync.Mutex
}

func (c *Counter) Increment() {
    c.mutex.Lock()
    defer c.mutex.Unlock()
    c.count++
}

func (c *Counter) GetValue() int {
    c.mutex.Lock()
    defer c.mutex.Unlock()
    return c.count
}

func main() {
    counter := Counter{}
    for i := 0; i < 1000; i++ {
        go counter.Increment()
    }
    time.Sleep(time.Second)
    fmt.Println(counter.GetValue())
}

在上面的例子中，我们定义了一个Counter结构体，其中包含一个count字段和一个互斥锁mutex。Increment方法用于增加count的值，GetValue方法用于获取count的值。在主协程中启动了1000个协程，这些协程同时对count进行增加操作。通过互斥锁的机制，确保了对count的访问是安全的。