如何延迟直播？

偷偷努力，悄无声息地变强，然后惊艳所有人！哈哈，小伙伴们又来学习啦~今天我将给大家介绍《如何延迟直播？》，这篇文章主要会讲到等等知识点，不知道大家对其都有多少了解，下面我们就一起来看一吧！当然，非常希望大家能多多评论，给出合理的建议，我们一起学习，一起进步！

我正在尝试在 go 中构建一项服务，该服务将直播流 (socketio/signalr) 延迟约 7 分钟。它还应该允许无延迟的流。因此，go 服务应该有类似缓冲区或队列之类的东西，强制数据等待指定的持续时间，然后才允许使用。在 go 中你会如何做这样的事情？延迟流会是一个单独的 goroutine 吗？应该使用什么数据结构来延迟数据？

我当前的想法是使用 time 包等待/滴答 7 分钟，然后才允许使用数据，但这种阻塞行为在这种情况下可能不是最佳的。

这里有一些代码来解释我想要做什么。 fakestream 是一个模拟函数，用于模拟我从​​外部服务获取的实时流数据。

package main

import (
    "fmt"
    "time"
)

func DelayStream(input chan string, output chan string, delay string) {

    // not working for some reason
    // delayDuration, _ := time.ParseDuration(delay)
    // fmt.Println(delayDuration.Seconds())

    if delay == "5s" {
        fmt.Println("sleeping")
        time.Sleep(5 * time.Second)
    }
    data := <-input
    output <- data
}

func FakeStream(live chan string) {

    ticks := time.Tick(2 * time.Second)
    for now := range ticks {
        live <- fmt.Sprintf("%v", now.Format(time.UnixDate))
    }
}

func main() {
    liveData := make(chan string)
    delayedData := make(chan string)

    go FakeStream(liveData)
    go DelayStream(liveData, delayedData, "5s")

    for {
        select {
        case live := <-liveData:
            fmt.Println("live: ", live)
        case delayed := <-delayedData:
            fmt.Println("delayed: ", delayed)
        }
    }
}

由于某种原因，延迟通道仅输出一次，并且不输出预期的数据。它应该输出直播频道中的第一件事，但事实并非如此。

解决方案

您需要足够大小的缓冲区。对于简单的情况，缓冲的 go 通道可以工作。

问问自己 - 在此延迟期间要存储多少数据 - 您应该有一个合理的上限。例如，如果您的流每秒传送多达 n 个数据包，则要延迟 7 分钟，您需要存储 420n 个数据包。

问问自己 - 如果在延迟窗口期间到达的数据多于预期，会发生什么情况？您可以扔掉新数据，或者扔掉旧数据，或者只是阻塞输入流。其中哪些对于您的场景是可行的？每个结果都会产生略有不同的解决方案。

问问自己 - 延迟是如何计算的？从创建流的那一刻起？从每个数据包到达的那一刻起？每个数据包的延迟是单独的，还是仅针对流中的第一个数据包？

您需要大幅缩小此处的设计选择范围，以便开发一些示例代码。

对于这些设计选择的某些子集，以下是在每条消息的通道之间添加延迟的简单方法：

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    // in is a channel of strings with a buffer size of 10
    in := make(chan string, 10)

    // out is an unbuffered channel
    out := make(chan string)

    // this goroutine forwards messages from in to out, ading a delay
    // to each message.
    const delay = 3 * time.Second
    go func() {
        for msg := range in {
            time.Sleep(delay)
            out <- msg
        }
        close(out)
    }()

    var wg sync.WaitGroup
    wg.Add(1)
    // this goroutine drains the out channel
    go func() {
        for msg := range out {
            fmt.Printf("Got '%s' at time %s\n", msg, time.Now().Format(time.Stamp))
        }
        wg.Done()
    }()

    // Send some messages into the in channel
    fmt.Printf("Sending '%s' at time %s\n", "joe", time.Now().Format(time.Stamp))
    in <- "joe"

    time.Sleep(2 * time.Second)
    fmt.Printf("Sending '%s' at time %s\n", "hello", time.Now().Format(time.Stamp))
    in <- "hello"

    time.Sleep(4 * time.Second)
    fmt.Printf("Sending '%s' at time %s\n", "bye", time.Now().Format(time.Stamp))
    in <- "bye"
    close(in)

    wg.Wait()
}

到这里，我们也就讲完了《如何延迟直播？》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！