简单的Go并发示例

Question

What would be a simple example of concurrency being used to increase execution speed? I've found a number of examples which use parallelism but none that just use concurrency.

Answer 1

Concurrency and parallelism are two related, but different things. The topic is broad, but let me briefly focus here on the speed.

Concurrency is related to how design and structure a program in a way that, if parallelism can be applied, then the software may run faster.

For example; if you have a loop such as

x := []int{1, 2, 3, 4, 5, 6}
for i := range x {
  x[i] *= x[i];
}

this program "feels" concurrent, because the read and write instructions that compute the square of each number in the array are logically independent one from the other. So, you could theoretically design your code in a concurrent way, for example by using goroutines:

x := []int{1, 2, 3, 4, 5, 6}
for i := range x {
  go func(j int) { x[j] *= x[j]; }(i)
}
wait_the_goroutines();

Assume for now that there are no data races in this example, and each update can be done independently. Well, the update of those values could be made in parallel, because the concurrent design allows it. With the old code, the update is serial by design.

Parallelism comes in when the computer (CPU, GPU, etc) is able to process multiple instructions at once, in the exact same time. If you have one core in your computer, the goroutines above are unlikely executed in parallel. If you have multiple cores, they may be executed in parallel - because they can be, but you have no actual control on how your computer's parallel hardware is used to execute the code in parallel. That's a task for the go runtime.

In some sense, concurrency is not used to increase execution speed: parallelism is. Concurrency is used to allow correct parallelization of code.

Therefore, you cannot really get such example, because even if you can get a "very concurrent" code, the execution speed is bounded to two things:

1. how much you can parallelize
2. how the go runtime will schedule the goroutines.