标签: channel

在Go中,我阅读文档并理解make和之间的基本差异new

• new:返回一个指针(*T)和它指向的零值
• make:返回类型T.

我阅读文档,主要是使用数组的示例.我在创建数组时理解newvs.make但是在创建频道时我不明白差异:

c1 := new(chan string)
c2 := make(chan string)

除了c1具有类型(chan*)和c2具有类型chan之外,真正的差异是什么.

谢谢

我开始使用Go,我现在正在编写一个简单的程序,它从传感器中读取数据并将其放入一个通道中进行一些计算.我现在的工作如下:

package main

import (
    "fmt"
    "time"
    "strconv"
)

func get_sensor_data(c chan float64) {
    time.Sleep(1 * time.Second)  // wait a second before sensor data starts pooring in
    c <- 2.1  // Sensor data starts being generated
    c <- 2.2
    c <- 2.3
    c <- 2.4
    c <- 2.5
}

func main() {

    s := 1.1

    c := make(chan float64)
    go get_sensor_data(c)

    for {
        select {
        case s = <-c:
            fmt.Println("the next value of s from the channel: " + strconv.FormatFloat(s, …

编写这个非常基本的代码来理解通道。

1. 如果一个 Goroutine 中有等待，为什么主 Goroutine 还要等待它呢？我读到主 Goroutine 需要有一个等待时间，因为在调用 Goroutine 后控制权会立即传回给它。

2. 为什么goroutine不像java中的主线程和子线程那样设计可以并行运行？

func main() {
    channel := make(chan int)
    go func() {
        time.Sleep(3*time.Second)
    }()

    for {
        fmt.Println("../");
        <-channel
    }
}

我有这个程序：

package main

import (
    "fmt"
    "time"
)

var ch1 = make(chan int)
var ch2 = make(chan int)

func f1() {
    select {
    case <-ch1:
        fmt.Println("ch1")
    }
}
func f2() {
    select {
    case <-ch2:
        fmt.Println("ch2")
    }
}
func main() {
    go f1()
    go f2()
    time.Sleep(2 * time.Second)
    fmt.Println("no buffered channel will wait?")
    ch1 <- 1
    ch2 <- 2
    fmt.Println("main exits")
}

我想到的是，只要F1和F2不显示任何信息，这意味着CH1和CH2具有里面什么都没有，所以ch1<-1和ch2<-2应该阻止？

但是当运行时，它会打印：

no buffered channel will wait?
main exits

为什么那些无缓冲通道ch1，并ch2没有阻止内主？ …

我正在尝试编写自己的睡眠功能,相当于在Go中time.Sleep使用time.After.

这是代码.第一次尝试:

func Sleep(x int) {
  msg := make(chan int)
  msg := <- time.After(time.Second * x)
}

第二次尝试:

func Sleep(x int) {
 time.After(time.Second * x)
}

两者都返回错误,有人可以向我解释如何编写等同于time.Sleep使用的睡眠功能time.After,如果可能的话,何时使用通道？

我在这里迷失了方向，我试图让一个goroutine添加到数组中，并从中读取另一个goroutine，我怀疑它与下面的内容有些相似，但我需要尝试使用wait（） 。

但是，我遇到了错误prog.go:19:14: too many variables in range，第19行是for _, v := range c {我在网上找不到答案，我在做什么或不做什么？

package main

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

func hello(wg *sync.WaitGroup, s []int, c chan int) {
    for _, v := range s {
        c <- v
    }
    fmt.Println("Finished adding to channel")
    wg.Done()
}

func hello2(wg *sync.WaitGroup, c chan int) {
    fmt.Println("Channel",c)
    for _, v := range c {
        fmt.Println("Received",v)   
    }
    fmt.Println("Finished taking from channel")
    wg.Done()
}

func main() {
    s := …

我目前正在盯着以下代码的增强版本:

func embarrassing(data []string) []string {
  resultChan := make(chan string)
  var waitGroup sync.WaitGroup
  for _, item := range data {
    waitGroup.Add(1)
    go func(item string) {
      defer waitGroup.Done()
      resultChan <- doWork(item)
    }(item)
  }

  go func() {
    waitGroup.Wait()
    close(resultChan)
  }()

  var results []string
  for result := range resultChan {
    results = append(results, result)
  }
  return results
}

这只是在想我的想法.所有这一切都可以用其他语言表达为

results = parallelMap(data, doWork)

即使在Go中不能轻易做到这一点,是不是还有比上面更好的方法呢？

以下代码记录了一个错误：

致命错误：所有goroutine都在睡着-死锁！

package main

import "fmt"

func main() {
    ch := make(chan int)
    ch <- 1
    fmt.Println(<-ch)
}

但是，当我将代码更改为：

package main

import "fmt"

func assign (ch chan int) {
    ch <- 1
}

func main() {
    ch := make(chan int)
    go assign (ch)

    fmt.Println(<-ch)
}

打印出“ 1”。

然后我使用了缓冲通道：

package main

import "fmt"

func main() {
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

也可以打印“ 1”和“ 2”。

我对此情况有些困惑。提前致谢！

考虑以下来自go 之旅的示例。

如何确定频道的接收顺序？为什么 x 总是从 gorouting 获得第一个输出？这听起来很合理，但我没有找到任何关于它的文档。我尝试添加一些睡眠，但仍然从第一次执行的 gorouting 中获取输入。

    c := make(chan int)
    go sumSleep(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // receive from c

    fmt.Println(x, y, x+y)

睡眠是在发送到通道之前。

我在select声明中有以下代码.finish是类型的bool.实际上,只要我收到任何东西,我甚至都不关心它的价值.但是,Go给了我一个未使用的变量错误.我怎么能绕过它呢？

case finish := <- termSig:

我目前的解决方法是Println(finish).

我试过了: -

case _ := <- termSig:

但这也不起作用.

我想使用 node js 在 websocket 服务器中创建一个通道并向订阅者发送消息。我需要一个简单的代码来开始。感谢您的帮助。

我是新来编程的人。这是我的代码。我试图将值分配给一个结构并将该结构分配给通道。但这不是设置它，而是要使用默认情况。

package main
import (
    "fmt"
)
type object struct {
    a int
    b string
}
func main() {

    o1 := object{
        a: 25,
        b: "quack",
    }

    var oc chan object
    select {
    case oc <- o1:
        fmt.Println("Chan is set")
    default:
        fmt.Println("Chan is not set")
    }
}

下面的代码：

// Sample program to show how to use the WithDeadline function
// of the Context package.
package main

import (
    "context"
    "fmt"
    "time"
)

type data struct {
    UserID string
}

func main() {

    // Set a duration.
    // duration := 150 * time.Millisecond
    duration := time.Now().Add(3 * time.Second)

    // Create a context that is both manually cancellable and will signal
    // a cancel at the specified duration.
    ctx, cancel := context.WithDeadline(context.Background(), duration)
    defer cancel()

    // Create a channel …