В чем разница между конкурентностью и многопоточностью?

Конкурентность и многопоточность: концептуальные различия

В Go разработке понимание разницы между конкурентностью (concurrency) и многопоточностью (multithreading) критически важно для создания эффективных программ. Это не синонимы, а взаимосвязанные, но различные концепции.

Конкурентность (Concurrency)

Конкурентность — это архитектурный паттерн проектирования программы, где независимые задачи могут выполняться в произвольном порядке без влияния на результат. Это свойство программы, а не среды выполнения.

Ключевые характеристики:

• Модель поведения программы, а не исполнения
• Обработка нескольких задач за период времени с возможностью переключения между ними
• Не требует нескольких ядер CPU — может работать на одном ядре
• Акцент на структуре программы и разделении ответственности
• В Go реализуется через горутины (goroutines) и каналы (channels)

// Пример конкурентности в Go
package main

import (
    "fmt"
    "time"
)

func task(name string, delay time.Duration) {
    for i := 1; i <= 3; i++ {
        fmt.Printf("%s: шаг %d\n", name, i)
        time.Sleep(delay)
    }
}

func main() {
    // Конкурентное выполнение двух задач
    go task("Задача A", 150*time.Millisecond)
    go task("Задача B", 100*time.Millisecond)
    
    time.Sleep(1 * time.Second)
}

Многопоточность (Multithreading)

Многопоточность — это техническая реализация параллельного выполнения, где несколько потоков выполняются одновременно на разных ядрах CPU. Это свойство среды выполнения, а не программы.

Ключевые характеристики:

• Модель исполнения на уровне операционной системы
• Физическое одновременное выполнение на нескольких ядрах CPU
• Требует многоядерного процессора для истинного параллелизма
• Операционная система управляет планированием потоков
• Связана с параллелизмом (parallelism)

Сравнительная таблица

Как Go объединяет обе концепции

Go предлагает уникальный подход, где конкурентность является языковой конструкцией, а многопоточность — оптимизацией времени выполнения:

1. Горутины — легковесные конструкции для конкурентности (могут выполняться в одном потоке)
2. Планировщик Go — распределяет горутины по системным потокам (многопоточность)
3. GOMAXPROCS — контролирует количество системных потоков для параллельного выполнения

// Демонстрация разницы на практике
package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

func main() {
    // Показываем разницу между конкурентностью и многопоточностью
    fmt.Printf("Количество ядер CPU: %d\n", runtime.NumCPU())
    fmt.Printf("GOMAXPROCS (потоки): %d\n", runtime.GOMAXPROCS(0))
    
    var wg sync.WaitGroup
    
    // Конкурентные задачи (горутины)
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            // Имитация работы
            time.Sleep(100 * time.Millisecond)
            fmt.Printf("Горутина %d выполнена\n", id)
        }(i)
    }
    
    wg.Wait()
}

Практическое значение для разработчика

1. Конкурентность позволяет писать более чистый, модульный код, где задачи логически разделены
2. Многопоточность обеспечивает реальное ускорение на многоядерных системах
3. В Go вы проектируете конкурентные программы, а runtime решает, как использовать многопоточность
4. Каналы и select в Go — инструменты для безопасной конкурентности без явной работы с потоками

Главный вывод: Конкурентность в Go — это способ мышления и проектирования программ, в то время как многопоточность — это способ выполнения этих программ операционной системой. Идеальная Go программа использует конкурентность для структурирования кода, а многопоточность — для эффективного использования ресурсов CPU.