Skip to content

Latest commit

 

History

History
243 lines (179 loc) · 7.67 KB

15.md

File metadata and controls

243 lines (179 loc) · 7.67 KB
Raw

第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 链接