Golang и “concurrency”

#golang

На официальной русской страничке документации Golang сообщается:


  Термин "concurrency" в
  программировании, судя по всему, не
  имеет точного аналога в русском языке.
  Хотя многие переводят его как
  "параллелизм", это ошибка (см.
  Parallelism is not concurrency), так
  же как в математике "concurrent lines"
  — вовсе не "параллельные прямые", а
  прямые, имеющие общую точку. Русский
  язык резиновый, он выдержит еще один
  термин: "конкарентность",
  "конкарентный".


Это замечание, тем не менее, совершенно не раскрывает само понятие и суть явления
этого "concurrency". В чем оно заключается?

Дополнение:
С учетом вот этого вопроса, я так понимаю, что goroutine НЕ выполняются параллельно
(не в геометрическом, а в смысле одновременного выполнения). Только как это все работает
и что под этим подразумевается все равно не понимается.
    

Ответы

Ответ 1

Заключается в том, что в каком-то месте программы образуется «вилка» из нитей выполнения
кода. Т.е. до этого места логическая цепочка была одна и последовательная, но в этом
месте она раздваивается и дальше идёт уже две логических цепочки последовательных действий,
выполняемых параллельно. Далее, обычно, они сливаются обратно, либо какие-то ветви
просто прекращают существовать отработав свою логику.
Т.е. термин достаточно точный, просто непосвящённый человек может подумать в рамках
геометрии, что раз параллельные потоки, то они не пересекаются, а это не совсем так.
Они параллельны не везде.


Ответ 2

Если говорить о примере из Вашего вопроса, то там проблема заключается в том что
одина рутина пишет в переменную в инфинити лупе, в то время как другая рутина пытается
получить доступ к той же переменной(как я это вижу).
Если, к примеру, поставить паузу в цикле который пишет в переменную, то main будет
выводить новое значение переменной:

type myInt struct {
    Value int64
}

func (i *myInt) add(x int64) int64 {
    i.Value += x
    return i.Value
}

func (i *myInt) setValue(x int64) {
    i.Value = x
}

func (i *myInt) getValue() int64 {
    return i.Value
}

var x myInt

func inc_x() { //test
    for {
        x.add(1)
        time.Sleep(1 * time.Nanosecond)
    }
}

func main() {
    go inc_x()
    for {
        fmt.Print("x=")
        fmt.Println(x.getValue())
        //      time.Sleep(1 * time.Second)
    }
}