Skip to content

Latest commit

 

History

History
243 lines (179 loc) · 7.67 KB

File metadata and controls

243 lines (179 loc) · 7.67 KB

第15节 管道模式


❤️💕💕Java和Golang的设计模式,设计模式介绍、创建者模式、结构型模式、行为型模式。Myblog:http://nsddd.top


[TOC]

管道模式

管道模式是一种Go语言设计模式,它使用管道连接一系列数据处理组件,这些组件将输入进行转换并将其输出到下一个组件。这种模式非常适合需要处理大量数据的情况,因为它可以有效地利用多核处理器来并行处理数据。

管道模式通过将一系列处理步骤组合成一个处理流水线来处理数据。在 Go语言 中,管道模式可以借助 Go语言 的强大并发特性和channel 来实现。

管道的基本结构

管道是一种连接输入和输出组件的通信机制。它由输入端(生产者)和输出端(消费者)组成。生产者将数据写入管道,消费者从管道中读取数据,并对数据进行处理。由于管道是一个阻塞式的通信机制,当管道已满或已空时,写入或读取数据的操作将被阻塞。

使用管道模式的基本结构如下所示:

func main() {
    data := make(chan int)
    go producer(data)
    consumer(data)
}

func producer(data chan int) {
    for i := 0; i < 10; i++ {
        data <- i
    }
    close(data)
}

func consumer(data chan int) {
    for num := range data {
        fmt.Println(num)
    }
}

在这个例子中,我们创建了一个名为data的管道,并启动了一个producer协程来向管道中写入数据。producer协程将0到9的整数写入管道,并在完成后关闭管道。同时,我们还启动了一个consumer协程来从管道中读取数据并进行打印操作。

管道模式的应用

管道模式可以应用于各种场景,例如:

数据过滤

管道模式可以用于对数据进行过滤,例如,从一个文件中读取数据并只保留满足特定条件的数据。

func main() {
    data := make(chan int)
    go producer(data)
    evenNumbers := filter(data, func(num int) bool {
        return num%2 == 0
    })
    consumer(evenNumbers)
}

func filter(data chan int, filterFunc func(int) bool) chan int {
    filteredData := make(chan int)
    go func() {
        defer close(filteredData)
        for num := range data {
            if filterFunc(num) {
                filteredData <- num
            }
        }
    }()
    return filteredData
}

在这个例子中,我们创建了一个名为data的管道,并启动了一个producer协程来向管道中写入数据。然后我们通过filter函数将数据传递给一个名为evenNumbers的管道,该管道仅包含偶数。最后,我们启动了一个consumer协程来从evenNumbers管道中读取数据并进行打印操作。

数据转换

管道模式可以用于对数据进行转换,例如,从一个文件中读取数据并将其转换为另一种格式。

type person struct {
    Name string
    Age  int
}

func main() {
    data := make(chan string)
    go producer(data)
    people := transform(data, func(line string) person {
        parts := strings.Split(line, ",")
        name := parts[0]
        age, _ := strconv.Atoi(parts[1])
        return person{Name: name, Age: age}
    })
    consumer(people)
}

func transform(data chan string, transformFunc func(string) person) chan person {
    transformedData := make(chan person)
    go func() {
        defer close(transformedData)
        for line := range data {
            transformedData <- transformFunc(line)
        }
    }()
    return transformedData
}

在这个例子中,我们创建了一个名为data的管道,并启动了一个producer协程来向管道中写入数据。然后我们通过transform函数将数据传递给一个名为 people 的管道,该管道包含了转换后的 person 对象。最后,我们启动了一个consumer协程来从people管道中读取数据并进行打印操作。

案例

package main

import (
    "fmt"
)

// 管道模式是一种Go语言设计模式,它使用管道连接一系列数据处理组件,
// 这些组件将输入进行转换并将其输出到下一个组件。这种模式非常适合需要处理大量数据的情况,
// 因为它可以有效地利用多核处理器来并行处理数据。

// producer函数用于向管道中写入数据
func producer(data chan int) {
    for i := 0; i < 10; i++ {
        data <- i
    }
    close(data)
}

// filter函数用于对数据进行过滤
func filter(data chan int, filterFunc func(int) bool) chan int {
    filteredData := make(chan int)
    go func() {
        defer close(filteredData)
        for num := range data {
            if filterFunc(num) {
                filteredData <- num
            }
        }
    }()
    return filteredData
}

// transform函数用于对数据进行转换
type person struct {
    Name string
    Age  int
}

func transform(data chan string, transformFunc func(string) person) chan person {
    transformedData := make(chan person)
    go func() {
        defer close(transformedData)
        for line := range data {
            transformedData <- transformFunc(line)
        }
    }()
    return transformedData
}

// consumer函数用于从管道中读取数据并进行打印操作
func consumer(data chan int) {
    for num := range data {
        fmt.Println(num)
    }
}

func main() {
    // 在这个例子中,我们创建了一个名为data的管道,并启动了一个producer协程来向管道中写入数据。
    data := make(chan int)
    go producer(data)

    // 然后我们通过filter函数将数据传递给一个名为evenNumbers的管道,该管道仅包含偶数。
    evenNumbers := filter(data, func(num int) bool {
        return num%2 == 0
    })

    // 最后,我们启动了一个consumer协程来从evenNumbers管道中读取数据并进行打印操作。
    consumer(evenNumbers)

    // 在这个例子中,我们创建了一个名为data的管道,并启动了一个producer协程来向管道中写入数据。
    data2 := make(chan string)
    go producer(data2)

    // 然后我们通过transform函数将数据传递给一个名为people的管道,该管道包含了转换后的person对象。
    people := transform(data2, func(line string) person {
        parts := strings.Split(line, ",")
        name := parts[0]
        age, _ := strconv.Atoi(parts[1])
        return person{Name: name, Age: age}
    })

    // 最后,我们启动了一个consumer协程来从people管道中读取数据并进行打印操作。
    for p := range people {
        fmt.Println(p)
    }
}

优缺点

管道模式的优点包括:

  • 有效地利用多核处理器,实现并行处理
  • 拆分逻辑,代码更容易理解,降低代码复杂度
  • 可以轻松地实现数据过滤和转换
  • 简化了组件之间的通信,减少了组件之间的耦合

缺点包括:

  • 如果管道中的一个组件崩溃,整个管道都会受到影响
  • 管道模式可能会导致性能下降,因为在管道中传递数据会带来一定的开销

END 链接