Почему все горутины спят?

Question

Почему все горутины спят?

Это касается того, как я решил выдать множественное наследование с разными переменными для инициализации и иметь несколько MixIns с тем же вызовом функции. Мне пришлось явно добавлять переменные в переданные ** kwargs и добавлять интерфейс MixIn в качестве конечной точки для супервызов.

Здесь A - расширяемый базовый класс, а B и C - MixIn классы, которые предоставляют функцию f. A и B оба ожидают параметр v в своих __init__ и C ожидает w. Функция f принимает один параметр y. Q наследуется от всех трех классов. MixInF - это интерфейс mixin для B и C.


class A(object):
    def __init__(self, v, *args, **kwargs):
        print "A:init:v[{0}]".format(v)
        kwargs['v']=v
        super(A, self).__init__(*args, **kwargs)
        self.v = v


class MixInF(object):
    def __init__(self, *args, **kwargs):
        print "IObject:init"
    def f(self, y):
        print "IObject:y[{0}]".format(y)


class B(MixInF):
    def __init__(self, v, *args, **kwargs):
        print "B:init:v[{0}]".format(v)
        kwargs['v']=v
        super(B, self).__init__(*args, **kwargs)
        self.v = v
    def f(self, y):
        print "B:f:v[{0}]:y[{1}]".format(self.v, y)
        super(B, self).f(y)


class C(MixInF):
    def __init__(self, w, *args, **kwargs):
        print "C:init:w[{0}]".format(w)
        kwargs['w']=w
        super(C, self).__init__(*args, **kwargs)
        self.w = w
    def f(self, y):
        print "C:f:w[{0}]:y[{1}]".format(self.w, y)
        super(C, self).f(y)


class Q(C,B,A):
    def __init__(self, v, w):
        super(Q, self).__init__(v=v, w=w)
    def f(self, y):
        print "Q:f:y[{0}]".format(y)
        super(Q, self).f(y)

0

go concurrency deadlock channel goroutine

задан Flimzy 5 March 2019 в 08:43

1 ответ

Другие вопросы по тегам:

go concurrency deadlock channel goroutine

Похожие вопросы:

score 0 · Answer 1

Ваш канал не буферизован, поэтому первая отправка по нему будет блокироваться, пока кто-то не получит от него. Но код, который будет получать от него, идет после этого, так что это «немедленный» тупик.

Вы можете сделать его небуферизованным, как ch := make(chan int, 1), так что отправка не будет блокироваться, но тогда у вас есть одна процедура, которая имеет for range по каналу. Этот цикл завершается, только если канал закрывается, но вы никогда не закрываете его. И вы отправляете только одно значение, поэтому цикл блокируется, ожидая значений, которые он может получить, или канала, который будет закрыт.

Вам нужна другая программа, которая когда-нибудь закроет канал. И внутри цикла, вам не нужно снова получать от канала, конструкция цикла уже делает это. i будет значением, полученным из канала.

Рабочий пример, который имеет какой-либо смысл:

func func1(n int) {
    ch := make(chan int)
    go func() {
        for i := 0; i < 5; i++ {
            ch <- i
        }
        close(ch)
    }()
    for i := range ch {
        fmt.Println(i)
    }
}

Это выводит (попробуйте на Go Playground ):