标签: channel

嘿,大家好 我正在尝试使用App Engine Channel API(此处记录)为我的应用程序启用推送更新.但是,我在设置初始化通信通道的机制时遇到了一些问题.

问题是,当我加载有问题的页面时,我得到onError和onClose处理程序的调试打印,但我没有得到onOpen处理程序的调试打印.没有其他事情发生.以下是使用Google Chrome开发者工具的javascript控制台输出:

资源解释为脚本,但使用MIME类型text/html进行传输...... jsapi:-1

onError ..... 443088:88

onClose ..... 443088:80

这里是我的Django模板的(大部分)javascript代码的相关部分:

<script type="text/javascript">
onOpen = function() {
   console.debug('onOpen');

   var xhrArgs = {
      url: '/channel/connect/',
      headers: { 'Content-Type': 'application/json' },
      postData: dojo.toJson({ 'channel_token': '{{ channel_token }}' }),
      handleAs: 'text',
      load: function(response) {
         alert('success');
      },
      error: function(error) {
         alert('failure: ' + error);
      }
   };
   var deferred = dojo.xhrPost(xhrArgs);
 };

 onClose = function() {
  console.debug('onClose');
 };

 onMessage = function(msg) {
  console.debug('onMessage');
 };

 onError = function() { …

如果两个go例程写入同一通道，我是否必须锁定？

我想打开显示特定频道的YouTube应用,但这只会执行浏览器.

try 
        {
            Intent intent = new Intent(Intent.ACTION_VIEW);
            intent.setData(Uri.parse("http://www.youtube.com/"+channel));
            startActivity(intent);
        }
        catch (Exception e) 
        {
            startActivity(new Intent(Intent.ACTION_VIEW,Uri.parse("http://www.youtube.com/"+channel)));         
        }

我想表明这一点:

我正在搞乱Photoshop中的RGB通道,并在我删除红色通道的可见性时找到了我想要的东西,并保持蓝色和绿色.当我去保存我的图像时,它将其保存为完整的RGB.如何暂时从图像中删除红色通道以进行保存？我附上了一张照片以寻求帮助.谢谢,

之前,

我多么希望它得救,

我尝试用并行的goroutine编写一个复杂的程序.这是我的第一个带有通道的程序;)每个goroutine返回一个数组,不幸的是,结果是"随机的".如果我运行10次程序,我有10个不同的结果:(

这是我的程序的过度简化,结果很好(可能因为它太简单了)但是当我用-race参数运行它时,有4个数据竞争.

我试过有一个close()函数,但它没有用.

你可以帮我找错吗？非常感谢你提前!

package main

import "fmt"
import "sync"
import "strconv"


func cat_strings(a int, b string) []string{
    var y []string

    j := strconv.Itoa(a)
    y = append(y, j)
    y = append(y, b)
    return y
}

func main() {
    var slice []string
    var wg sync.WaitGroup
    var x []string

    queue := make(chan []string, 10)

    wg.Add(10)
    for i := 0; i < 10; i++ {
        go func(i int) {
            defer wg.Done()
            x = cat_strings(i, "var")
            queue <- x
        }(i)

    }
    //close(queue)

    go func() …

考虑以下去游乐场

    package main

    import "fmt"

    func main() {
        messages := make(chan string)

        messages <- "my msg"

        select {
        case msg := <-messages:
            fmt.Println("received message", msg)
        }

    }

上面的代码会出错

fatal error: all goroutines are asleep - deadlock!

然而

如果我改成它

    package main

    import "fmt"

    func main() {
        messages := make(chan string)

        go func() {
            messages <- "my msg"
        }()
        select {
        case msg := <-messages:
            fmt.Println("received message", msg)
        }

    }

它会工作.

这种行为有特殊原因吗？

代码不应该在第一种情况下以顺序方式执行,以便在达到select语句时,msg将被传递并且它将捕获大小写msg := <-messages？

这段代码与函数参数中的channel运算符有关:

func Worker(item <- chan string)

而这个代码在函数参数中没有通道运算符:

func Worker(item chan string)

这段代码用于我的编程语言类的一个相当简单的演示.我试图显示Go允许的一些不同的技术,比如接口和并发,但我似乎无法让WaitGroups正常工作,所以它最终会让我陷入僵局.我最大的问题是:当goroutines停止时,如何让WaitGroups正确同步并且不会使系统死锁？我很可能错过了一些明显的东西.

package main

import (
    "bufio"
    "fmt"
    "os"
    "sync"
)


func Reader(wg *sync.WaitGroup, message chan string, done chan bool){
defer wg.Done()
        reader := bufio.NewReader(os.Stdin)
        for {

            msg, _ := reader.ReadString('\n')
            if msg == "exit\n" {
                <-done
                return
            } else {
                message <- msg
            }

        }

 }

func main() {
    message := make(chan string)
    done := make(chan bool)
    wg := &sync.WaitGroup{}


    wg.Add(1)
    go Reader(wg, message, done) 


    wg.Add(1)
    go func(){
    defer wg.Done()
        for {
            select {
            case <-done:
                return
            case msg := …

我读了sync.Pool设计，但发现有两种逻辑，为什么我们需要localPool来解决锁竞争。我们可以使用chan来实现一个。

使用频道的速度是的4倍sync.pool！

除了池可以清除对象外，它还有什么优势？

这是池实现和基准测试代码：

package client

import (
    "runtime"
    "sync"
    "testing"
)

type MPool chan interface{}


type A struct {
    s        string
    b        int
    overflow *[2]*[]*string 

}

var p = sync.Pool{
    New: func() interface{} { return new(A) },
}

var mp MPool = make(chan interface{}, 100)

func get() interface{} {
    select {
    case r := <-mp:
        return r
    default:
        return new(A)
    }
}

func put(a interface{}) {
    select {
    case mp <- a:
    default:
    }
    return …

我正在尝试创建一个命令行测验，在该测验中，用户将被问到另一个问题，直到他们完成最后一个问题或超时为止。

我想使用频道，以便我可以学习如何正确使用它们，而且可以说，我遇到了障碍。

这个想法是将correctAnswersCh从0开始，在每个正确答案之后，它将递增1。

在将零放入通道后，测验总是在quiz（）函数的第3行停止。

我在下面添加了一些代码，但是完整的代码在这里：https : //play.golang.org/p/vzRCTc7MpIK

func main() {
    questions, err := getCsvData()
    var limit = time.Duration(3)


    flag.Parse()

    if err != nil {
        log.Fatal(err)
    }

    quizComplete := make(chan bool)
    correctAnswersCh := make(chan int)
    go quiz(quizComplete, questions, correctAnswersCh)

    select {
    case <-time.After(limit*time.Second):
        fmt.Println("Timed Out")
    }
    fmt.Printf("Correct Answers: %v\n", <-correctAnswersCh)
}

func quiz(quizComplete chan bool, questions [][]string, correctAnswersCh chan int) {
    reader := bufio.NewReader(os.Stdin)
    correctAnswersCh <- 0
    // execution stops here.  0 is added to correctAnswersCh, then the quiz func …