Многопоточность — Java: Продвинутое использование

• Многозадачность
• Многопоточность
  • Многопоточность и многозадачность
• Возможности многопоточности
• Процесс и поток
  • Состояние потоков
• Проблемы многопоточности
  • Состояние гонки
  • Deadlock
  • Голодание потоков

Многозадачность

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

Она позволяет пользователю работать с несколькими приложениями, например, слушать музыку, писать текст и просматривать интернет одновременно. Операционная система управляет ресурсами компьютера, чтобы каждая программа могла получать необходимое время и память для работы. Это делает использование компьютера более удобным и эффективным.

Без многозадачности пользователь мог бы запускать только одно приложение за раз. Например, если мы слушаем музыку,то смогли бы одновременно просматривать новости в интернете — для этого пришлось бы закрывать одно приложение, чтобы открыть другое. Это сделало бы использование компьютера менее удобным и эффективным

Многозадачность не является свойством языка программирования Java, а является функцией операционной системы. Язык Java может использовать многозадачность через потоки, которые создаются на основе системных потоков операционной системы для выполнения нескольких задач одновременно. Java предоставляет API для создания и управления этими потоками, но сама операционная система управляет их выполнением и ресурсами. Таким образом, многозадачность является фундаментальной функцией операционной системы, которая позволяет языкам программирования, таким как Java, создавать более эффективные и удобные приложения

Многопоточность

Многопоточность — это возможность программы выполнять несколько задач одновременно, используя так называемые потоки. Поток — это отдельная часть программы, которая может работать параллельно с другими потоками.

Многопоточность и многозадачность

Многозадачность и многопоточность - это два понятия, которые часто путают друг с другом, но они имеют разные значения, работают на разных уровнях. Многозадачность касается управления несколькими программами на уровне операционной системы. Например, вы открываете браузер и текстовый редактор, одновременно набираете текст и слушаете музыку. Многопоточность позволяет выполнять несколько задач внутри одной программы. Например, браузер загружает данные из интернета и одновременно отображает информацию на экране, не дожидаясь завершения загрузки.

Таким образом основная разница между многозадачностью и многопоточностью заключается в том, что многозадачность относится к выполнению нескольких программ или процессов одновременно, а многопоточность относится к выполнению нескольких задач или потоков внутри одной программы или процесса.

По-настоящему параллельное выполнение задач возможно только в многоядерной системе, поскольку только в них присутствуют несколько системных конвейеров для исполнения команд. В одноядерной многозадачной системе поддерживается так называемое псевдопараллельное исполнение, при котором создается видимость параллельной работы нескольких процессов. В таких системах процессы выполняются последовательно, занимая малые кванты процессорного времени.

Возможности многопоточности

Многопоточность - это мощный инструмент, который широко используется в приложениях с пользовательским интерфейсом. Основная идея многопоточности заключается в том, чтобы разделить задачи на несколько потоков, что позволяет выполнять несколько задач одновременно. Это особенно полезно в приложениях, где за работу интерфейса отвечает один поток, а какие-либо вычисления выполняются в других потоках.

Таким образом, пользовательский интерфейс не подвисает, когда приложение занято другими вычислениями. Например, если вы открываете текстовый редактор и начинаете набирать текст, редактор может выполнять другие задачи, такие как проверка орфографии или автосохранение документа, в отдельных потоках. Это позволяет интерфейсу редактора оставаться отзывчивым и не подвисать.

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

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

Процесс и поток

Процесс и поток — это два ключевых понятия в области операционных систем, которые относятся к выполнению программ

Процесс — это экземпляр выполняемой программы. Он включает в себя не только код программы, но и все необходимые ресурсы для её выполнения, такие как память, открытые файлы и состояние выполнения, кроме процесорного времени. Каждый процесс имеет свою собственную область памяти, что обеспечивает изоляцию между процессами. Это значит, что один процесс не может напрямую обращаться к памяти другого процесса, что помогает предотвратить ошибки и конфликты.

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

Разница между процессом и потоком заключается в том, что процесс — это способ организовать все необходимые ресурсы для выполнения программы, а потоки — это единицы выполнения, которые используют процессорное время для выполнения конкретных задач. Таким образом, процессы организуют ресурсы, а потоки выполняют работу.

Потоки легче создавать и управлять, так как они используют общие ресурсы процесса. Потоки могут легко обмениваться данными и взаимодействовать друг с другом, так как они работают в одной области памяти.

Состояние потоков

Потоки в операционной системе могут находиться в различных состояниях в зависимости от того, что они делают в данный момент. Эти состояния помогают управлять выполнением потоков и оптимизировать использование ресурсов процессора. Вот основные состояния потока:

• Выполняемый (Executing) - поток, который выполняется в текущий момент на процессоре.
• Готовый (Runnable) - поток ждет получения кванта времени и готов выполнять назначенные ему инструкции. Планировщик выбирает следующий поток для выполнения только из готовых потоков.
• Ожидающий (Waiting) - работа потока заблокирована в ожидании блокирующей операции.

Проблемы многопоточности

Многопоточность может значительно повысить производительность и отзывчивость приложений, но она также может привести к различным проблемам, которые затрудняют разработку и отладку. Вот некоторые из основных проблем, с которыми могут столкнуться разработчики при работе с многопоточными системами

Состояние гонки

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

Это наш разделяемый ресурс

class Counter {

    private int counter = 0;

    public void increment() {
        counter++;
    }

    public int getCounter() {
        return counter;
    }
}

Два потока пытаются изменить наш разделяемый ресурс без синхронизации. Например, поток 1 считывает текущее значение counter, а затем поток 2 также считывает это значение до того, как поток 1 успевает его обновить, оба потока могут записать одно и то же значение, что приводит к потере инкремента.

class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });

        thread1.start();
        thread2.start();
        thread2.join();
        thread1.join();
        // Значение счетчика каждый запуск будет разным
        // Практически никогда оно не будет равно 20000
        System.out.println(counter.getCounter()); // 14836
    }
}

В результате, при каждом запуске программы значение счетчика, выводимое на экран, будет разным и, как правило, не будет равно ожидаемому значению 20000

Deadlock

Deadlock (взаимная блокировка) — это ситуация, при которой несколько потоков находятся в состоянии ожидания ресурсов, занятых друг другом, и ни один из них не может продолжать выполнение. Например, поток A может удерживать ресурс 1 и ожидать ресурс 2, в то время как поток B удерживает ресурс 2 и ожидает ресурс 1. В результате оба потока застревают, и система не может продолжать работу, что приводит к потере производительности и необходимости ручного вмешательства для разрешения ситуации

Голодание потоков

Голодание потоков — это ситуация, в которой поток не может получить доступ к общим ресурсам, потому что на эти ресурсы всегда претендуют другие потоки, которым отдается предпочтение. Это может произойти, если планировщик потоков неравномерно распределяет процессорное время или если некоторые потоки имеют более высокий приоритет. В результате, потоки с низким приоритетом могут никогда не получить возможность выполнить свою работу

class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });

        thread1.start();
        thread2.start();
        thread2.join();
        thread1.join();
        // Значение счетчика каждый запуск будет разным
        // Практически никогда оно не будет равно 20000
        System.out.println(counter.getCounter()); // 14836
    }
}

Класс потока

class Counter {

    private int counter = 0;

    public void increment() {
        counter++;
    }

    public int getCounter() {
        return counter;
    }
}

---

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты