Содержание

Многопоточность в Java · GitHub

  • Monitor — высокоуровневый механизм взаимодействия и синхронизации процессов, обеспечивающий доступ к неразделяемым ресурсам.

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

    • Семафоры используются для синхронизации и защиты передачи данных через разделяемую память, а также для синхронизации работы процессов и потоков.
  • Mutex — двоичный простейший семафор, который может находиться в одном из двух состояний: отмеченном или неотмеченном. Он отличается от семафора тем, что только владеющий им поток может его освободить, т. е. перевести в отмеченное состояние.

    • Задача мьютекса — защита объекта от доступа к нему других потоков, отличных от того, который завладел мьютексом.
    • В каждый конкретный момент только один поток может владеть объектом, защищённым мьютексом.
    • Если другому потоку будет нужен доступ к переменной, защищённой мьютексом, то этот поток блокируется до тех пор, пока мьютекс не будет освобождён.
  • Reentrant mutex — мьютекс, который может быть залочен несколько раз одиним и тем же процессом/потоком без создания взаимной блокировки.

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

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

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

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

  • Process — процесс обладает автономной средой выполнения.

    • Каждый процесс, в частности, имеет собственную область памяти.
    • Процесс обычно воспринимается, как синоним выполнению программы или приложения. Однако бывает, что одна приложения занимает несколько процессов.
    • Большинство реализаций JVM запускаются в едином процессе.
    • Java приложение может создать дополнительный процесс с помощью ProcessBuilder объекта.
  • Thread — потоки иногда называют легковесными процессами (lightweight processes). Потоки существуют внутри процесса — каждый процесс обладает хотя бы одним потоком.

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

  • Join — позволяет одному потоку ждать окончание выполнения другого потока.

  • Thread safe — участок кода, который работает корректно как в однопоточной, так и в многопоточной среде.

    • Not thread safe — участок кода, который работает корректо только в однопоточной среде.
  • Thread affinity

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

  • EDT (Event Dispatching Thread) — специальный поток, используемый для обработки событий из очереди событий. Такой подход является концептом событийно-ориентированного программирования.

    • Такие GUI фреймворки, как, например, AWT или Swing, используют EDT.
  • Race condition — ошибка проектирования многопоточной системы или приложения, при которой работа системы или приложения зависит от того, в каком порядке выполняются части кода.

  • Context switches — когда планировщик временно приостанавливает работу потока, чтобы активировать другой поток.

    • Частое явление в приложениях с кучей потоков, что очень дорого им обходится из-за:
    • Сохранение и восстановление выполняемого контекста
    • Непостоянное местоположение в памяти
    • Затрачивание CPU на планирование потоков, которое нужно тратить на их использование.
  • Atomic action (Атомарная операция) — операция, выполняющаяся как единое целое, либо не выполняющаяся вовсе.

    • Атомарная операция не может быть прервана: она либо выполняется полностьбю, либо не выполняется вовсе.
    • Атомарная операция не производит изменений внешней среды во время выполнения, только по окончании.
    • Атомарная операция открыта влиянию только одного потока.
  • Happened-before relationship — отношение «выполняется прежде» двух событий, которое гарантирует, что память, записанная событием A будет видна для события B, т.е. событие А завершает свою запись перед тем, как B начнет чтение.

    • Данное отношение транзитивно, иррефлексивно, антисимметрично.
    • Транзитивно — для любых 3-х событий a, b, c, если событие a происходит перед b, и b происходит перед c, тогда a должно происходить перед c.
    • Иррефлексивно — ни одно событие не должно происходить перед собой.
    • Антисимметрично — если событие a должно произойти перед событием b, то обратное невозможно.
  • Critical section — участок кода, в котором производится доступ к общему ресурсу, который не должен быть одновременно использован более чем одним потоком.

    • Мьютекс является процедурой входа/выхода из критической секции.
  • Собеседование по Java Concurrency | Стартекст

    Взято отсюда: http://www.rsdn.ru/forum/java/3622844.flat.aspx

    В последнее время во многих вакансиях на Java Developer появилось требование знания Java Concurrency/Multithreading. В ответ многие разработчики тут же добавили такую строчку себе в резюме. Я как человек, который проводит собеседования, хотел бы развеять некоторые недоразумения относительно этого термина.
    Все проекты связанные с многопоточностью я бы разделил на 3 класса: использующие многопоточность, основанные на многопоточности и те, которые и есть сама многопоточность. К первому классу(«использующие») я бы отнес проекты, которые предполагают работу в многопоточной среде. Пример: есть класс BlaBlaBlaFactory, в документации необходимо указать, может ли эта фабрика использоваться одновременно несколькими потоками или нет. Если нет, то сделать ее потокобезопасной с помощью ReentrantLock. Ко второму классу («основанные на») я бы отнес проекты, в которых использование нескольких потоков является одним из ключевых моментов. Пример: многопоточный кодек видео формата H.264. К третьему классу («являются ей») я бы отнес проекты, в корне что-то меняющие в отношении потоков. Пример: написание runtime-среды для языка Scala (на Java) с реализацией легковесных потоков и своеобразной моделью памяти.

    Так вот, дело в том, что разработчик зачастую указывает на свое знание java concurrency имея в виду первый уровень. Компания же может иметь в виду второй (написание высоконагруженного сервера, написание физического/AI ядра 3D-шутера, написание OLAP-системы — во всех случаях с требованием ОДИН запрос пользователя обрабатывать в НЕСКОЛЬКО потоков). Иногда разработчики не знают про существование уровней выше первого.
    Особенную лепту в это вносят книги вводного или обзорного характера.
    Ниже я привожу ряд вопросов с гипотетического собеседования по java concurrency, относящиеся как к первому так и ко второму уровню. Надеюсь кому-то они покажут направление, в котором возможно развиваться.
    Как и на всяком собеседовании, не предполагается, что интервьюируемый ответит на все вопросы. Но предполагается, что опрашиваемый по-крайней мере ознакомлен с тематикой. Кроме того определение того 1) что кандидат знает; 2) о чем слышал; 3) о чем не слышал; позволяет составить о нем более полное мнение.

    1. Назовите различия между Collections.synchronizedMap(new HashMap()) и ConcurrentHashMap.
    2. Что такое кооперативная многозадачность и она ли ли в Java. Если да, то какие преимущества. Если нет, то какая тогда в Java?

    3. Что такое «зеленый потоки» и они ли ли в Java (в HotSpot JVM.6)?
    4. Различия в интерфейсах Runnable и Callable.
    5. Напишите минимальный неблокирующий стек (всего два метода — push() и pop()).
    6. Напишите минимальный copy-on-write ArrayList (всего четыре метода — void add(int indx, int item), int get(int indx), void remove(int indx), int size()).
    7. Различя между Thread.isInterrupded() и Thread.interrupded().
    8. Что происходит при вызове Thread.interrupt()?
    9. Некоторые из следующих методов deprecated а некоторые и не были никогда реализованы. Какие? Thread.interrupt(), Thread.stop(), Thread.yield(), Thread.suspend(), Thread.resume(), Thread.join(), Thread.start(), Thread.run(), Thread.sleep().
    10. Что Вы знаете о асинхронных вызовов методов? Есть ли это в самом языке Java? Если есть, то как реализовано? Если нет, то как бы Вы реализовали?
    11. Перечислите ВСЕ причины по которым может выскочить InterruptedException.
    12. Что изменилось между JMM до Java 5 и NewJMM после Java 5?
    13. В классе String все поля финальные. Можно ли убрать ключевое слово финал? Ведь сеттеров все равно нет — следовательно поля нельзя переустановить.
    14. Что такое ordering, visibility, atomicity, happend-before, mutual exclusion. И показать на примерах volatile, AtomicInteger, synchronize{} — что из вышеперечисленного списка присутствует и при каких вариантах использования.
    15. Назовите отличия synchronize{} и ReentrantLock.
    16. Что из данных вызовов создает happend-before: Thread.sleep(), Thread.join(), Thread.yield(), Thread.start(), Thread.run(), Thread.isAlive(), Thread.getState()?
    17. Перечислите известные Вам способы борьбы с priority inversion, назовите классы систем где они особенно опасны.
    18. Перечислите известные Вам способы 1)избежать 2)побороть возникшие deadlock-и (представьте, что вы пишете ядро RDBMS).
    19. Расскажите о паттернах Reactor/Proactor?
    20. Что такое «monitor»?
    21. Что такое «private mutex»?
    22. Что такое «priority inheritance»?
    23. Что такое «backoff protocol (expotential backoff)»?
    24. Что такое «task stealing»?
    25. Что такое «ABA problem»?
    26. Что такое «test-end-set»?
    27. Что такое «test-and-test-end-set»?
    28. Что такое «spin lock»?
    29. Что такое «sequential consistency»?
    30. Что такое «sense-reversing barrier»?
    31. Что такое «safe publication»?
    32. Что это за свойство — «reentrancy»?
    33. Что такое «recursive parallelism»?
    34. Что такое «iterative parallelism»?
    35. Что это за вариант архитектуры «pipeline»?
    36. Что такое «poison message»?
    37. Что такое «mutual exclusion»? Примеры как добиться в Java.
    38. Что такое «condition waiting»? Примеры как добиться в Java.
    39. Преимущества SheduledThreadPool перед java.util.Timer.
    40. Различия между java.util.concurrent.Atomic*.compareAndSwap() и java.util.concurrent.Atomic*.weakCompareAndSwap().
    41. Что в SynchronousQueue уникально для BlockingQueue.
    42. Что такое «рандеву»? При помощи каких классов в Java его можно организовать?
    43. Что такое «false sharing». Может ли происходит в Java. Если есть, то приведите примеры и как бороться. Если нет, то как побороли разработчики JVM.
    44. Thread.getState() возвращает экземпляр Thread. State. Какие возможны значения?
    45. Напишите простейший ограниченный буфер для многих производителей/многих потребителей с использованием synchronize{}. С использованием ReentrantLock.
    46. У ReentrantLock созданного с аргументом true все же один из методов захвата блоктровки — не fair. Какой? Как это обойти?
    47. Приведите наиболее существенное отличие между CountDownLatch и Barrier.
    48. Что Вы знаете о Erlang? Что в нем есть существенного связанного с многопоточностью такого, чего нет в Java?
    49. Что Вы знаете о CSP? Что в нем есть существенного связанного с многопоточностью такого, чего нет в Java?
    50. Отличие Thread.start() и Thread.run()?

    Модель потоков Java


     Модель потоков Java

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

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

    Выгода от многопоточности состоит в том, что основной механизм циклического опроса исключается. Один поток может быть приостановлен без остановки других частей программы. Например, время ожидания при чтении данных из сети либо ожидание пользовательского ввода может быть утилизировано где угодно. Многопоточность позволяет циклам анимации «засыпать» на секунду между показом соседних кадров, не приостанавливая работы всей системы. Когда поток блокируется в программе Java, то останавливается только один-единственный заблокированный поток. Все остальные потоки продолжают выполняться.

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

    Runnable и Thread. Курс «Программирование на Java»

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

    Та часть кода, которая должна выполняться в отдельном потоке, выносится в свой класс, имеющий переопределенный метод run(). Код метода run() выполняется, когда к объекту типа Thread применяется метод start(). Непосредственный вызов run() новый поток не создает.

    Рассмотрим пример:

    public class ThreadTest {
        public static void main(String[] args) 
                     throws InterruptedException {
     
            AnotherRun anotherRun = new AnotherRun();
            Thread childTread = new Thread(anotherRun);
            childTread.start();
     
            for (int i = 0; i < 3; i++) {
                System.out.println("m" + i);
                Thread.sleep(1000);
            }
     
            childTread. join();
            System.out.println("End");
        }
    }
     
    class AnotherRun implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("r" + i);
                try {
                    Thread.sleep(1000);
                }
                catch (InterruptedException e) {
                    System.out.println("Interrupt");
                }
            }
        }
    }

    Результат выполнения:

    m0
    r0
    m1
    r1
    m2
    r2
    r3
    r4
    End

    Здесь обработка исключений необходима из-за статического метода sleep(), который приостанавливает выполнение текущего потока. Данный метод часто используют в дочерних потоках, когда они должны выполнять какое-либо действие постоянно, но не бесперебойно. Например, периодически проверять доступность ресурса.

    Метод join() заставляет текущий поток ждать завершения нити, к которой применяется. Только после этого текущий поток может продолжить выполнение своего кода.

    В данном случае мы создаем класс-наследник от Runnable. Объект типа Runnable или его производное передается в конструктор объекта типа Thread. После этого поток запускается.

    Другой вариант – когда пользовательский класс является наследником Thread:

    public class ThreadTest1 {
        public static void main(String[] args) 
                 throws InterruptedException {
     
            AnotherTask thread = new AnotherTask();
            thread.start();
     
            for (int i = 0; i < 3; i++) {
                System.out.println("m" + i);
                Thread.sleep(1000);
            }
     
            thread.join();
            System.out.println("End");
        }
    }
     
    class AnotherTask extends Thread {
        @Override
        public void run(){
            for (int i = 0; i < 5; i++) {
                System.out.println("r" + i);
                try {
                    Thread.sleep(1000);
                }
                catch (InterruptedException e) {
                    System.out.println("Interrupt");
                }
            }
        }
    }

    Этот вариант не подходит, если класс для организации отдельного потока должен наследоваться от другого класса (не Thread). Поскольку в Java нет множественного наследования классов, приходится использовать наследование от интерфейса Runnable. Также данный подход не дает возможности запускать несколько потоков на основе одного объекта. Так в первом примере мы могли бы передать единственный объект anotherRun в несколько объектов типа Thread.

    Напомним, библиотечный класс Thread сам является наследником Runnable.

    Если в отдельный поток обособляется небольшая подзадача, можно использовать неименованный класс:

    public class ThreadNoName {
        public static void main(String[] args) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hi");
                }
            });
            thread.start();
     
            Thread thread1 = new Thread() {
                @Override
                public void run() {
                    System.out.println("hello");
                }
            };
            thread1.start();
        }
    }

    Прерывание потоков

    Для прерывания выполнения нити, если это необходимо, используется метод interrupt(), который устанавливает переменную isInterrupt в значение true. К коде пользовательского класса, унаследованного от Runnable/Thread, это переменная должна проверяться. Отсюда следует, что на самом деле в Java нет возможности прервать поток извне, поток может остановиться только сам.

    С другой стороны, в метод sleep() уже встроена проверка переменной isInterrupt, поэтому проверку вручную опускают. Если sleep() считывает наличие прерывания, то генерирует исключение.

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
     
    public class ThreadInterrupt {
        public static void main(String[] args) 
                       throws IOException {
            Thread thread = new InterruptedClass();
            thread.start();
            BufferedReader reader = new BufferedReader(
                     new InputStreamReader(System.in));
            reader.readLine();
            thread.interrupt();
        }
    }
     
    class InterruptedClass extends Thread {
        @Override
        public void run() {
            while (true) {
                System.out.print("a");
                try {
                    sleep(1000);
                }
                catch (InterruptedException e) {
                    break;
                }
            }
        }
    }

    В примере основной поток ожидает ввод данных, в это время выполняется вторая нить. Но как только вы нажмете Enter, выполнится метод interrupt(). В свою очередь метод sleep() прочитает значение переменной isInterrupt класса Thread и сгенерирует исключение InterruptedException.

    Если sleep() не используется, то isInterrupt проверяется вручную методом isInterrupted(). Следующий пример содержит ошибку, приводящую к зацикливанию:

    public class ThreadInterrupt2 {
        static int a = 1;
        public static void main(String[] args) 
                 throws InterruptedException {
            Thread thread = new WithoutSleep();
            thread.start();
            Thread.sleep(2000);
            thread.interrupt();
        }
    }
     
    class WithoutSleep extends Thread {
        @Override
        public void run() {
            while (true) {
                System.out.println("hi");
            }
        }
    }

    Мы могли бы ожидать, что через 2 секунды сработает метод interrupt(), который прервет дочернюю нить. Однако, поскольку в ней не проверяется значение isInterrupt, цикл продолжает работать. Корректный код может выглядеть так:

    class WithoutSleep extends Thread {
        @Override
        public void run() {
            while (!this. isInterrupted()) {
                System.out.println("hi");
            }
        }
    }

    При наследовании от Runnable текущий поток через this получить нельзя. Его получают, вызывая соответствующий метод класса Thread:

    class WithoutSleep2 implements Runnable {
        @Override
        public void run() {
            Thread cur = Thread.currentThread();
            while (!cur.isInterrupted()) {
                System.out.println("hi");
            }
        }
    }

    Многопоточность в Java – Not only Java

    Это – перевод статьи “Threading in Java” автора Beka Kodirov. Вторая часть статьи находится здесь.

    Чем отличается поток от процесса?

    Процессы были разработаны для обеспечения многозадачности в операционных системах. Все приложения живут в рамках процессов, а память и ЦПУ выделяются напрямую ядром ОС. При желании можно запустить часть вашего приложения внутри отдельного процесса. Каждый процесс обычно содержит следующую информацию:

    • PID – уникальный идентификатор процесса
    • PPID – идентификатор родительского процесса
    • UID – идентификатор пользователя
    • Heap – пространство памяти, выделенное для данного процесса. Каждый процесс обладает собственным пространством.

    По умолчанию каждый процесс содержит минимум один поток (обычно main- или ui-). Как только все потоки завершаются, процесс уничтожается. Процесс может иметь множество потоков, но поток может принадлежать только одному процессу.

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

    Все потоки в Java являются нативными Linux-потоками или т. н.pthreads. Поток принадлежит процессу, в котором он был создан.

    Сравните совместную и вытесняющую многозадачность

    Существует несколько типов многозадачности – невытесняюшая, совместная, вытесняющая.

    Совместная многозадачность

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

    Вытесняющая многозадачность

    Более современный подход, при котором распределением ресурсов между процессами занимается операционная система. При этом достигается меньшее время отклика на действия пользователя. В основе этого подхода лежит приоритезация: процесс с низким приоритетом может быть приостановлен более важным.

    Что такое “Green Threads” и есть ли они в Java (HotSpot JVM 7)?

    В Java был добавлен новый тип потоков, названный “зелёный поток”. Он имитирует native поток, то есть за весь жизненный цикл зелёного потока и переключение между ними отвечает JVM, а не ядро операционной системы.

    Но есть и недостатки. Самый значительный – невозможность выполнения одновременно двух потоков. Так как native поток всего один, даже если используется несколько процессоров и множество зелёных потоков, выполнять такой поток сможет только один ЦПУ.

    Что такое планировщик потоков? Какой алгоритм он использует?

    В системе, где одновременно работают несколько приложений, должен быть планировщик. Чтобы пользователь мог почувствовать всю мощь параллельного выполнения, ресурсы процессора должны распределяться между потоками разных приложений и именно это находится в зоне ответственности планировщика. Он решает какой поток запустить и как долго его выполнять. Стратегии планирования могут меняться, но обычно все они основываются на приоритете: поток с более высоким приоритетом получает ресурсы раньше, чем они достаются более “низкому” потоку. В Java приоритет потоков может иметь значение от 1 (самый низкий) до 10 (самый высокий). Приоритет по умолчанию равен 5.

    Каковы преимущества многопоточности в однопроцессорных системах?

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

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

    В чем разница между однопоточным и многопоточным в Java — Разница Между

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

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

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

    Ключевые области покрыты

    1. Что такое Single Thread в Java
      – Определение, Функциональность
    2. Что такое многопоточность в Java
      – Определение, Функциональность
    3. Разница между однопоточным и многопоточным в Java
      – Сравнение ключевых различий

    Основные условия

    Java, однопоточный, многопоточный, процесс


    Что такое Single Thread в Java

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

    Рисунок 1: Однопоточная программа на Java

    В приведенной выше программе a и b являются переменными типа integer. Есть объект типа HelloWord. Используя этот объект, программист может вызывать методы Add, Sub, Mul и Div. Эти методы выполняют сложение, вычитание, умножение и деление. Наконец, эти методы отображают ответы на консоли. Существует только один поток, и он отображает результаты.

    Что такое многопоточность в Java

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

    Рисунок 2: Мульти потоковая программа на Java

    Рисунок 3: Класс с основным методом

    HelloWorld — это класс, который реализует интерфейс Runnable. У метода run есть реализация. Runnable интерфейс имеет этот метод. Это отправная точка потока. Следовательно, бизнес-логика находится внутри этого метода. ThreadName — это имя нового потока. После создания объекта потока программист может запустить его с помощью метода start (). Выполняет метод run. В консоли видно, что два потока выполняются параллельно.

    Разница между однопоточным и многопоточным в Java

    Определение

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

    основа

    Один поток выполняет процесс в одном потоке. Несколько потоков выполняют процесс в многопоточности. Следовательно, это еще одно различие между однопоточным и многопоточным в Java.

    Заключение

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

    Ссылка:

    1. «Что такое многопоточность? — Определение от Techopedia. ”Techopedia.com,

    Вакансия Senior Android Developer (Digital Health) компании Ondoc на vc.ru, Санкт-Петербург

    Вакансия Senior Android Developer (Digital Health) компании Ondoc на vc.ru, Санкт-Петербург [ { «id»: 1, «label»: «100%×150_Branding_desktop», «provider»: «adfox», «adaptive»: [ «desktop» ], «adfox_method»: «createAdaptive», «auto_reload»: true, «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «bugf», «p2»: «ezfl» } } }, { «id»: 2, «label»: «1200х400», «provider»: «adfox», «adaptive»: [ «phone» ], «auto_reload»: true, «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «bugf», «p2»: «ezfn» } } }, { «id»: 3, «label»: «240х200 _ТГБ_desktop», «provider»: «adfox», «adaptive»: [ «desktop» ], «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «bugf», «p2»: «fizc» } } }, { «id»: 4, «label»: «Article Branding», «provider»: «adfox», «adaptive»: [ «desktop» ], «adfox»: { «ownerId»: 228129, «params»: { «p1»: «cfovx», «p2»: «glug» } } }, { «id»: 5, «label»: «300x500_desktop», «provider»: «adfox», «adaptive»: [ «desktop» ], «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «bugf», «p2»: «ezfk» } } }, { «id»: 6, «label»: «1180х250_Interpool_баннер над комментариями_Desktop», «provider»: «adfox», «adaptive»: [ «desktop» ], «adfox»: { «ownerId»: 228129, «params»: { «pp»: «h», «ps»: «bugf», «p2»: «ffyh» } } }, { «id»: 7, «label»: «Article Footer 100%_desktop_mobile», «provider»: «adfox», «adaptive»: [ «tablet», «phone» ], «adfox»: { «ownerId»: 228129, «params»: { «p1»: «bwkpg», «p2»: «fjxb» } } }, { «id»: 8, «label»: «Fullscreen Desktop», «provider»: «adfox», «adaptive»: [ «desktop», «tablet» ], «auto_reload»: true, «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «bugf», «p2»: «fjoh» } } }, { «id»: 9, «label»: «Fullscreen Mobile», «provider»: «adfox», «adaptive»: [ «phone» ], «auto_reload»: true, «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «bugf», «p2»: «fjog» } } }, { «id»: 10, «disable»: true, «label»: «Native Partner Desktop», «provider»: «adfox», «adaptive»: [ «desktop», «tablet» ], «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «clmf», «p2»: «fmyb» } } }, { «id»: 11, «disable»: true, «label»: «Native Partner Mobile», «provider»: «adfox», «adaptive»: [ «phone» ], «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «clmf», «p2»: «fmyc» } } }, { «id»: 12, «label»: «Кнопка в шапке», «provider»: «adfox», «adaptive»: [ «desktop» ], «adfox»: { «ownerId»: 228129, «params»: { «p1»: «bscsh», «p2»: «fdhx» } } }, { «id»: 13, «label»: «DM InPage Video PartnerCode», «provider»: «adfox», «adaptive»: [ «desktop», «tablet», «phone» ], «adfox_method»: «createAdaptive», «adfox»: { «ownerId»: 228129, «params»: { «pp»: «h», «ps»: «bugf», «p2»: «flvn» } } }, { «id»: 14, «label»: «Yandex context video banner», «provider»: «yandex», «yandex»: { «block_id»: «VI-223676-0», «render_to»: «inpage_VI-223676-0-1104503429», «adfox_url»: «//ads. adfox.ru/228129/getCode?pp=h&ps=bugf&p2=fpjw&puid1=&puid2=&puid3=&puid4=&puid8=&puid9=&puid10=&puid21=&puid22=&puid31=&puid32=&puid33=&fmt=1&dl={REFERER}&pr=» } }, { «id»: 15, «label»: «Баннер в ленте на главной», «provider»: «adfox», «adaptive»: [ «desktop», «tablet», «phone» ], «adfox»: { «ownerId»: 228129, «params»: { «p1»: «byudx», «p2»: «ftjf» } } }, { «id»: 16, «label»: «Кнопка в шапке мобайл», «provider»: «adfox», «adaptive»: [ «tablet», «phone» ], «adfox»: { «ownerId»: 228129, «params»: { «p1»: «byzqf», «p2»: «ftwx» } } }, { «id»: 17, «label»: «Stratum Desktop», «provider»: «adfox», «adaptive»: [ «desktop» ], «auto_reload»: true, «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «bugf», «p2»: «fzvb» } } }, { «id»: 18, «label»: «Stratum Mobile», «provider»: «adfox», «adaptive»: [ «tablet», «phone» ], «auto_reload»: true, «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «bugf», «p2»: «fzvc» } } }, { «id»: 19, «label»: «Тизер на главной 2», «provider»: «adfox», «adaptive»: [ «desktop», «tablet», «phone» ], «auto_reload»: true, «adfox»: { «ownerId»: 228129, «params»: { «p1»: «cbltd», «p2»: «gazs» } } }, { «id»: 20, «label»: «Кнопка в сайдбаре», «provider»: «adfox», «adaptive»: [ «desktop» ], «adfox»: { «ownerId»: 228129, «params»: { «p1»: «cgxmr», «p2»: «gnwc» } } }, { «id»: 21, «label»: «Ультратизер», «provider»: «adfox», «adaptive»: [ «desktop» ], «adfox»: { «ownerId»: 228129, «params»: { «pp»: «g», «ps»: «bugf», «p2»: «gtjk» } } } ] {«token»:»eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9. eyJwcm9qZWN0SWQiOiI1ZTRmZjUxODYyOGE2YzcxNDUxNWY0ZGEiLCJpYXQiOjE1ODI1MzY0NDB9.AwBBnUWMy3RR1xtAoaXVr81WvqxdlD4C8CBpwFiONzw»,»release»:»fe552c7f»} null Многопоточность

    в Java, часть I — Начало работы с Java Spring

    В моем предыдущем посте я описал основы многопоточности, вы можете проверить это здесь: http://www.zoltanraffai.com/blog/multithreading-and-concurrency -at-a-glance /

    Теперь я хотел бы показать вам, как именно это работает в Java, как настроить многопоточное приложение Java.

    Java Threading Foundation

    В Java существует множество различных уровней абстракции по сравнению с идеей многопоточности, но большинство из них очень ограничены: основные типы очень похожи, поскольку многопоточность работает в большинстве рабочих systems:

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

    Типы оснований для потоков

    У нас есть два основных типа для работы:

    Запускаемый интерфейс:

    • Представляет задачу для выполнения в потоке
    • Имеет только один член, который является запуском Метод

    Класс потока:

    • Представляет поток выполнения
    • Может взаимодействовать и может влиять на состояние потока
    • Чтобы начать выполнение, вы должны вызвать метод start

    Базовый пример реализации, который создает несколько файлы в многопоточном режиме:

    Здесь мы создали FileAdder класс , который реализует интерфейс Runnable .Интерфейс Runnable — это функциональный интерфейс , поэтому у него есть только один метод: run ().

    В нашем методе main мы создали новый поток Thread для каждого файла с заданным объектом FileAdder . Следовательно, каждый поток отвечает за свою собственную обработку исключений, нам не нужно писать здесь блок try-catch. Обработка исключений происходит в методе class run () FileAdder.

    Если вы напишете свою программу таким образом, у вас возникнет проблема:

    Основной поток запускает фоновый поток для всех восьми файлов, и после его завершения у него больше нет работы, поэтому он будет сброшен.
    После завершения основного потока весь процесс будет очищен, а некоторые фоновые потоки никогда не завершатся. Это может вызвать у нас серьезные ошибки в приложении.
    Чтобы предотвратить это, мы должны заставить Main Thread ждать завершения остальных Threads .
    Вы можете сделать это так:

    Здесь мы создали массив из элементов Thread и добавили все созданные Threads в этот массив. Как только мы это сделаем, мы можем перебрать все элементов массива и вызвать для них Join () . Это блокирует наш Основной поток до завершения до тех пор, пока весь объединенный поток не завершится, поэтому он гарантирует нам, что наш Процесс будет продолжать выполняться до тех пор, пока не будет завершена вся работа.
    Если поток уже завершился, когда мы вызываем для него join, он немедленно возвращается.

    Это очень простой код для управления пулами, и он по-прежнему вызывает некоторые проблемы. Что, если у нас есть 1000 файлов для управления вместо 8? Более того, эти файлы могут быть очень большими, и на их обработку нужно очень много времени? Если мы запустим 1000 потоков одновременно, это может серьезно задушить нашу систему.

    Подробная информация об управлении потоками

    Значение класса потока:

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

    Challange of the Thread class:

    • Отвечает за эффективное управление запуском, остановкой и координацией потоков.
    • Используется неправильно

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

    Пулы потоков

    • Создание очереди для задач
    • Назначает задачи пулу потоков
    • Обрабатывает детали управления потоками

    В Java есть два типа пулов потоков, которые дают нам разные тип абстракции:

    ExecutorServiceInterface

    • Модели поведения пула потоков
    • Может отправлять задачи
    • Запрос и ожидание завершения работы пула

    Класс исполнителей (Методы создания пулов потоков)

    • Пулы с динамическим размером
    • Пулы с ограниченным размером
    • Пулы, которые планируют задачи на более поздний период

    Давайте посмотрим на наш код, как это легко реализовать:

    Здесь мы создали ExecutorService с фиксированным размером 3. Мы отправили ему все наши задачи, который начинает выполнять их в том порядке, в котором мы добавили, но он управляет тем, что только 3 потока могут быть запущены одновременно:
    После третьего запуска он будет ждать запуска другого, пока один из забегов не закончится.
    Таким образом, не имеет значения, будет ли у нас 8 или 8000 файлов для обработки, стоимость нашей системы останется прежней.

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

    Узнайте больше о многопоточности здесь.

    Tagged #Spring #Java

    Java Multithreading | Код Тыква

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

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

    Java имеет встроенную поддержку параллелизма. В Java виртуальная машина Java (JVM) позволяет приложению иметь несколько потоков выполнения, выполняемых одновременно. Это позволяет программе быть более ответственной перед пользователем. Когда программа содержит несколько потоков, ЦП может переключаться между двумя потоками, чтобы выполнять их одновременно. Эта встроенная поддержка параллелизма является одной из самых сильных сторон java и помогла ей завоевать популярность.

    Если вы пойдете на какое-либо собеседование с ядром Java, вы обязательно столкнетесь с вопросами из-за многопоточности. Большинство прибыльных должностей Java-разработчиков требуют отличных знаний в области многопоточности и опыта разработки, отладки и настройки высокопроизводительных параллельных Java-приложений с низкой задержкой. Ниже приведены статьи, посвященные важным темам, и вопросы интервью, связанные с многопоточностью в JAVA.

    1. Определение и запуск потока | Поток VS Runnable
    2. Обмен данными между потоками с использованием методов wait (), notify () и notifyAll ()
    3. interrupt (), interrupted () и isInterrupted ()
    4. InterruptedException
    5. Безопасность нитей в одноэлементном шаблоне проектирования с использованием метода блокировки с двойной проверкой

    Утилиты параллелизма Java


    Многопоточность и параллелизм сложно освоить, и только хорошие разработчики с солидным опытом могут эффективно решить проблему параллелизма. Также недостаточно только базовых знаний о многопоточности. Вам необходимо узнать о различных утилитах, доступных в пакете java.util.concurrent . Вот список статей о различных параллельных пакетных утилитах. Хорошо подготовьтесь к следующему собеседованию по Java. 🙂

    1. CountDownLatch
    2. CyclicBarrier
    3. CountDownLatch против CyclicBarrier
    4. Шаблон потребительского дизайна производителя с использованием BlockingQueue
    5. Threadpool с использованием Executor Framework
    6. Hashtable против SynchronizedMap против ConcurrentHashMap

    Мы продолжим добавлять статьи в этот раздел.Следите за обновлениями 🙂 Если вы хотите, чтобы мы писали по какой-либо конкретной теме или вопросу интервью, вы можете связаться с нами через facebook или написать письмо на [адрес электронной почты защищен]


    25 самых часто задаваемых вопросов на собеседовании по многопоточности Java

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

    1 кв. Что такое нить?

    Поток — это легкий подпроцесс. Класс Thread принадлежит пакету java.lang. У потоков есть собственный стек. Это способ использовать преимущества нескольких процессоров, доступных на машине. Например, если одному потоку требуется 50 миллисекунд для выполнения задания, вы можете использовать 10 потоков, чтобы уменьшить эту задачу до 5 миллисекунд.

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

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

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

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

    Q3 Как можно реализовать поток в Java?


    Есть два способа реализовать Thread в java.
    1. Реализуя интерфейс Runnable в java, а затем создавая из него объект Thread.
    2. Расширяя класс Thread.

    Q4 В чем разница между реализацией Runnable и расширением Thread при создании потока в java? Какая из них лучше?

    Реализация Runnable лучше.

    Когда мы реализуем интерфейс Runnable, мы можем расширить любой другой класс, но если мы расширим класс Thread, мы не сможем расширить любой другой класс, потому что java не допускает множественного наследования.

    Здесь вы можете найти подробный ответ о разнице между реализацией Runnable и extends Thread.

    Q5 Что такое жизненный цикл потока?

    Когда мы создаем экземпляр потока в java-программе, его состояние новое. Затем мы запускаем поток, затем его состояние меняется на Runnable (готов к запуску, но еще не запущен). Выполнение потоков зависит от ThreadScheduler. ThreadScheduler отвечает за выделение процессоров потокам в пуле потоков Runnable и изменение их состояния на Running. Ожидание, Blocked и Dead — остальные состояния потока.

    Итак короче новые, работоспособные, ходовые.ожидающий, заблокированный и мертвый — это состояния, в которых может находиться поток.

    Q6 В чем разница между методами сна и ожидания в java?

    Метод ожидания снимает блокировку, а метод ожидания не снимает блокировку.
    Метод ожидания принадлежит классу java.lang.Object, тогда как метод сна принадлежит классу java.lang.Thread.

    Здесь вы можете найти подробный ответ о различиях между методами ожидания и сна в java.

    Q7 В чем разница между запуском потока с помощью метода start () и метода run ()?

    Этот вопрос немного сложный и может вас тоже запутать.Ответ: когда вы вызываете метод start (), основной метод внутренне вызывает метод run () для запуска вновь созданного потока, поэтому метод run в конечном итоге вызывается вновь созданным потоком.
    Когда вы вызываете метод run (), он вызывается в том же потоке, новый поток не запускается, что имеет место при вызове метода start ().

    Q8 В чем разница между потоком пользователя и потоком демона?

    Когда мы создаем поток в java-программе, он называется пользовательским потоком. Мы не можем сделать поток пользователя потоком демона, если поток запущен.

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

    Q9 Как создать поток демона в java?

    Установив setDaemon (true), мы можем создать поток демона в java.

    Q10 Какое значение имеет использование ключевого слова volatile?

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

    volatile — это ключевое слово, которое можно использовать только с переменными.

    Q11 Можно ли запустить поток дважды?

    Нет, нет возможности запустить поток дважды. Если мы это сделаем, это вызовет исключение.

    Q12 Что такое синхронизация?

    Синхронизация — это возможность управлять доступом нескольких потоков к любому общему ресурсу.
    Главное преимущество синхронизации —
    a. чтобы избежать проблем с согласованностью
    b. во избежание пересечения потоков

    Q13 Что предпочтительнее — блок синхронизации или метод синхронизации?

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

    Q14 Различия и сходства между методами сна и выхода?

    Метод сна выдает прерванное исключение, если другой поток прерывает спящий поток, в то время как метод yield не генерирует прерванное исключение.

    Метод Thread.sleep () не заставляет текущий выполняющийся поток отказываться от мониторов, в то время как метод yield отказывается от монитора.
    Вы можете найти подробное объяснение разницы между методами сна и выхода в java.

    Q15 Что такое тупик?

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

    Поток 1: блокирует ресурс A, ожидает ресурса B
    Поток 2: блокирует ресурс B, ожидает ресурса A

    Q16 Напишите программу для создания тупиковой ситуации в java?

    Здесь вы можете найти ответ Программа для создания тупика в java.

    Q17 Какие меры следует предпринять, чтобы избежать тупика?

    1. Блокируйте определенные переменные-члены класса, а не блокируйте весь класс.
    2. Используйте метод join (), если возможно, попробуйте использовать метод соединения, хотя он может удерживать нас от использования всех преимуществ многопоточной среды, потому что потоки будут запускаться и заканчиваться последовательно, но это может быть полезно для предотвращения взаимоблокировок.
    3. По возможности старайтесь избегать вложенных блоков синхронизации.

    Q18 Что вы понимаете под приоритетом потока?

    У каждого потока есть приоритет. Его значение — int , которое варьируется от 1 до 10, где 1 — самый низкий приоритет, а 10 — самый высокий приоритет.
    Обычно потоки с более высоким приоритетом получают более высокий приоритет при выполнении, но это зависит от реализации ThreadScheduler, которая зависит от ОС.
    Мы можем указать приоритет потока, но это не гарантирует, что поток с более высоким приоритетом будет выполнен раньше потока с более низким приоритетом.

    Q19 В чем разница между блокировкой класса и блокировкой объекта?

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

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

    Q20 В чем разница между Callable и Runnable?

    Callable генерирует проверенное исключение, в то время как Runnable не генерирует проверенное исключение.

    Тип возврата Runnable недействителен, то есть он не возвращает никакого значения, в то время как Callable может возвращать объект Future.
    Вы можете найти подробное объяснение разницы между вызываемым и исполняемым.

    Q21 В чем разница между квантованием времени и упреждающим планированием?

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

    Q22 Можно ли синхронизировать конструктор?

    Нет, Конструктор не может быть синхронизирован.

    Q23 Что такое состояние гонки в Java и как мы можем его решить?

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

    Q24 Как потоки взаимодействуют друг с другом?

    Потоки могут взаимодействовать друг с другом с помощью методов wait (), notify (), notifyAll ().

    Q25 Почему методы wait (), notify () и notifyAll () должны вызываться из синхронизированного контекста?

    Когда поток вызывает wait () для любого объекта, он должен иметь монитор на объекте, который он оставит, и переходит в состояние ожидания, пока какой-либо другой поток не вызовет notify () для этого объекта. Аналогично, когда поток вызывает notify () для любого объекта, он оставляет монитор на объекте, а другие ожидающие потоки могут получить монитор на объекте. Поскольку для всех этих потоков требуется, чтобы Thread имел монитор объектов, этого можно достичь только путем синхронизации.Вот почему методы wait (), notify () и notifyAll () должны вызываться из синхронизированного контекста.

    Q26 Что такое переменная ThreadLocal в java?

    ThreadLocal можно использовать для создания переменных ThreadLocal. Мы знаем, что все потоки объекта разделяют его переменные, поэтому, если переменная не является потокобезопасной, мы можем использовать синхронизацию. Если мы хотим избежать синхронизации, мы можем использовать переменные ThreadLocal.
    Каждый поток имеет свою собственную переменную ThreadLocal, и они могут использовать ее методы get () и set () для получения значения по умолчанию или изменения его значения, локального для Thread.

    Q27 Что такое Threadpool?

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

    Q28 Можете ли вы узнать, удерживает ли поток lock () на объекте или нет?

    Метод holdLock (Object) может использоваться для определения того, удерживает ли текущий поток блокировку монитора указанного объекта.
    Метод holdLock (Object) возвращает true, если поток удерживает блокировку или монитор указанного объекта.

    Если вы столкнетесь с каким-либо вопросом о многопоточности java, которого нет в приведенных выше вопросах, укажите в комментариях.

    Основы многопоточности — Вопросы и ответы по Java

    Этот раздел наших 1000+ MCQ посвящен основам многопоточности языка программирования Java.

    1. Что такое многопоточное программирование?
    a) Это процесс, в котором одновременно выполняются два разных процесса
    b) Это процесс, в котором две или более частей одного и того же процесса работают одновременно
    c) Это процесс, в котором множество разных процессов могут получить доступ к одной и той же информации
    d) Это процесс, в котором один процесс может получить доступ к информации из многих источников.
    View Answer

    Answer: b
    Explanation: Многопоточное программирование процесса, в котором две или более частей одного процесса выполняются одновременно.

    2. Какие из этих типов многозадачности?
    a) На основе процесса
    b) На основе потока
    c) На основе процесса и потока
    d) Ни одного из упомянутых
    Посмотреть ответ

    Ответ: c
    Объяснение: Существует два типа многозадачности: многозадачность на основе процесса и многозадачность на основе потоков.

    3. Приоритет потока в Java есть?
    a) Целое число
    b) Float
    c) double
    d) long
    Посмотреть ответ

    Ответ: a
    Объяснение: Java назначает каждому потоку приоритет, который определяет, что этот поток должен обрабатываться по отношению к другим.Приоритет потока — это целые числа, указывающие относительный приоритет одного потока перед другим.

    4. Что произойдет, если вызовут одновременную обработку двух потоков с одинаковым приоритетом?
    a) Любой будет выполнен первым лексографически
    b) Оба они будут выполняться одновременно
    c) Ни один из них не будет выполнен
    d) Это зависит от операционной системы
    Посмотреть ответ

    Ответ: d
    Объяснение: In В случаях, когда два или более потока с одинаковым приоритетом конкурируют за циклы ЦП, разные операционные системы обрабатывают эту ситуацию по-разному. Некоторые выполняют их в разрезе по времени, некоторые в зависимости от вызываемого потока.

    5. Какое из этих утверждений неверно?
    a) Благодаря многопоточности время простоя ЦП сводится к минимуму, и мы можем максимально использовать его
    б) Благодаря многозадачности время простоя ЦП сводится к минимуму, и мы можем использовать его максимально
    в) Два потока в Java могут иметь одинаковый приоритет
    d) Поток может существовать только в двух состояниях: запущен и заблокирован.
    Просмотреть ответ

    Ответ: d
    Объяснение: поток существует в нескольких состояниях, поток может быть запущен, приостановлен, заблокирован, завершен и готов к работе.

    6. Что будет на выходе следующего кода Java?

    1.  class multithreaded_programing 
    2.  {
    3.  public static void main (String args []) 
    4.  {
    5.  Thread t = Thread.currentThread (); 
    6.  System. out.println (t); 
    7. } 
    8. } 

    a) Тема [5, main]
    b) Тема [main, 5]
    c) Тема [main, 0]
    d) Тема [main, 5, main]
    Посмотреть ответ

    Ответ: d
    Пояснение: Нет.
    Выход:
     $ javac multithreaded_programing.java
    $ java multithreaded_programing
    Тема [основная, 5, основная] 

    7. Каков приоритет потока в следующей программе на Java?

    1.  class multithreaded_programing 
    2.  {
    3.  public static void main (String args []) 
    4.  {
    5.  Thread t = Thread.currentThread (); 
    6.  Система.out.println (t); 
    7. } 
    8. } 

    а) 4
    б) 5
    в) 0
    г) 1
    Посмотреть ответ

    Ответ: б
    Объяснение: Результатом программы является Thread [main, 5, main], в котором приоритет, назначенный потоку, равен 5. Это значение по умолчанию. Поскольку мы не назвали поток, он назван группой, к которой принадлежит основной метод.
    Выход:
     $ javac multithreaded_programing.java
    $ java multithreaded_programing
    Тема [основная, 5, основная] 

    8.Как называется поток в следующей программе на Java?

    1.  class multithreaded_programing 
    2.  {
    3.  public static void main (String args []) 
    4.  {
    5.  Thread t = Thread.currentThread (); 
    6.  System.out.println (t); 
    7. } 
    8. } 

    a) основной
    b) поток
    c) система
    d) ни один из упомянутых
    Посмотреть ответ

    Ответ: a
    Объяснение: Результатом программы является Thread [main, 5, main], так как мы явно не назвали поток, которому они назвали группу, к которой они принадлежат, i: e main метод.Отсюда их название «основные».
    Выход:
     $ javac multithreaded_programing. java
    $ java multithreaded_programing
    Тема [основная, 5, основная] 

    Sanfoundry Global Education & Learning Series — Язык программирования Java.

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

    Top Java Multithreading Interview Questions & Answers

    В этом руководстве мы увидим вопросы для интервью с несколькими заголовками с ответами.
    Вот список вопросов для интервью по многопоточности.
    1. Что такое Java?

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

    2. Что такое многопоточность?

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

    3. Как можно создать ветку в java?

    Ответ:
    Есть два способа создать поток в java

    • путем расширения класса потока
    • путем реализации интерфейса Runnable.

    Дополнительную информацию можно найти в примере потока Java.

    4. Thread vs Runnable, какой подход лучше для создания потока?

    Ответ:
    Реализация интерфейса Runnable считается лучшим подходом, чем расширение потока по следующим причинам.

    • Java не поддерживает множественное наследование, поэтому, если вы расширяете класс Thread, вы не можете расширять какой-либо другой класс, который необходим в большинстве случаев.
    • Runnable interface представляет собой задачу, которая может быть выполнена с помощью класса Thread или Executors.
    • Когда вы используете наследование, это потому, что вы хотите расширить некоторые свойства родителя, изменить или улучшить поведение класса. Но если вы расширяете класс потока только для создания потока, это может не быть рекомендованным поведением для объектно-ориентированного программирования.

    6. В чем разница между сном и ожиданием в java?

    Параметр

    ожидание

    спящий режим

    Синхонизированный

    контекстный метод, если вы должны быть вызваны из контекста 907 не вызывайте его с использованием синхронизированного контекста, он вызовет исключение IllegalMonitorStateException

    Его не нужно вызывать из синхронизированного блока или методов

    Вызовы

    Метод ожидания работает с объектом и определен в классе объекта

    Метод сна работает с текущим потоком и находится в java. lang.Thread

    Снятие блокировки

    ожидание освобождения блокировки объекта, для которого он вызван, а также других блокировок, если он содержит какие-либо

    Метод сна вообще не снимает блокировку

    Условие пробуждения

    до вызова notify () или notifyAll () из класса объекта

    Пока не истечет время или вызовет прерывание ()

    статический

    ожидание нестатический метод

    sleep — статический метод

    Ответ:
    В java есть 5 состояний потока

    Новый : когда вы создаете объект потока, но он еще не активен.

    Runnable: Когда вы вызываете метод запуска потока, он переходит в состояние Runnable. Будет ли он выполняться немедленно или через некоторое время, зависит от планировщика потоков.

    Работает: Когда поток выполняется, он переходит в рабочее состояние.

    Заблокировано: Когда поток ожидает завершения некоторых ресурсов или другого потока (из-за соединения потока), он переходит в заблокированное состояние.

    Мертвый: Когда метод выполнения потока возвращается, поток переходит в мертвое состояние.

    8. Можем ли мы вызвать метод run напрямую, чтобы запустить поток?

    Ответ:
    Нет, вы не можете напрямую вызвать метод run для запуска потока. Вам нужно вызвать метод start, чтобы создать новый поток. Если вы вызываете метод run напрямую, он не создаст новый поток и будет находиться в том же стеке, что и основной.
    Вы можете сослаться на то, можем ли мы вызвать метод запуска напрямую для запуска потока для получения более подробной информации.

    9. Можно ли запустить поток дважды в java?

    Ответ:
    Нет, после того, как вы запустили поток, он не может быть запущен снова. Если вы попытаетесь запустить поток снова, он выдаст исключение IllegalThreadStateException.
    Вы можете сослаться на возможность запуска потока дважды для получения более подробной информации

    10. Как заставить основной поток ждать, пока все остальные потоки не закончат выполнение?

    Ответ:
    Вы можете использовать метод соединения для достижения вышеуказанного сценария.
    Подробнее о методе соединения можно прочитать.

    11. Что такое потоки демона?

    Ответ:

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

    12. Как можно изменить поток пользователя на поток демона?

    Ответ: Метод setDaemon может использоваться для пометки потока как потока пользователя. Если вы установите setDaemon (true), он сделает поток демоном.

    13. Что такое синхронизация?

    Ответ:

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

    14. Зачем нужна синхронизация?

    Давайте разберемся в этом на примере.

    Допустим, вы хотите подсчитать количество запросов, полученных для определенного URL. Если вы получаете два запроса одновременно, счет может быть несовместимым.

    Без синхронизации:

    пакет орг.arpit.java2blog;

    Public class RequestCounter {

    private int count;

    public int incrementCount ()

    {

    count ++;

    счетчик возврата;

    }

    }

    Например:
    Поток T1 видит счет как 20 и увеличивает его до 21. В то же время поток t2 также видит счет как 20 и увеличивает его до 21. Это показывает, что подсчет стал непоследовательным.

    С синхронизацией:

    Вы можете выполнить синхронизацию двумя способами.

    • синхронизированный метод
    • синхронизированный блок

    Вы не можете использовать синхронизированный с переменными экземпляра или класса.

    синхронизированный метод

    Вы можете сделать весь метод incrementCount () синхронизированным, чтобы никакие два потока не могли обращаться к нему параллельно.

    упаковка орг.арпит.java2blog;

    Public class RequestCounter {

    private int count;

    общедоступная синхронизированная int incrementCount ()

    {

    count ++;

    счетчик возврата;

    }

    }

    Например:
    Поток T1 видит счет как 20 и увеличивает его до 21. В то же время поток t2 теперь будет видеть счет как 21 и увеличивать его до 22.

    синхронизированный блок

    Вы можете использовать блок для синхронизации критического раздела в методе incrementCount (), чтобы два потока не могли получить доступ к блоку одновременно.

    пакет org.arpit.java2blog;

    Public class RequestCounter {

    private int count;

    public int incrementCount () {

    synchronized (this) {

    count ++;

    счетчик возврата;

    }

    }

    }

    Например:
    Поток T1 видит счет как 20 и увеличивает его до 21.В то же время поток t2 теперь будет видеть счетчик как 21 и увеличивать его до 22.

    15. Не могли бы вы объяснить блокировку на уровне объекта и блокировку на уровне класса?
    16. Могут ли два потока выполнять статические и нестатические методы одновременно?

    Ответ:
    Да, поскольку два потока получают блокировку на разных объектах, они могут выполняться одновременно без каких-либо проблем.

    17. Если один метод класса синхронизирован, а другой метод того же класса не синхронизирован? Могут ли они выполняться одновременно двумя потоками?

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

    18. Безопасно ли вызывать синхронизированный метод из другого синхронизированного метода?

    Ответ:
    Да, можно безопасно вызывать синхронизированный метод из другого синхронизированного метода, потому что, когда вы вызываете синхронизированный метод, вы получаете блокировку этого объекта , а когда вы вызываете другой синхронизированный метод того же класса, это безопасно для выполнения, поскольку он уже заблокировал этот объект .
    Например:

    public synchronized void method1 () {

    method2 ();

    // некоторый код

    }

    public synchronized void method2 () {

    // некоторый код

    }

    Фактически вы это делаете.

    public void method1 () {

    synchronized (this) {

    method2 ();

    // некоторый код

    }

    }

    public void method2 () {

    synchronized (this) {

    // some code

    }

    }

    03

  • 67 Здесь, если какой-либо поток вызывает метод 2 из метода 1, он уже заблокирует этот объект , поэтому его можно безопасно выполнить.

    19. Что такое тупик?

    Ответ:
    Тупик — это ситуация, когда два или более потока ждут друг друга, чтобы освободить ресурс.

    Например:

    Поток 1 заблокировал объект 1 и ожидает блокировки объекта 2. Поток 2 заблокировал объект 2 и ожидает блокировки объекта 1. В этом сценарии оба потока будут ждать друг друга. бесконечно.

    20. В чем разница между notify и notifyall?

    Ответ:
    Вы можете просмотреть разницу между notify и notifyall, чтобы увидеть различия.

    Вам также может понравиться:

    Пещера программирования

    Многопоточность Java: Swing и SwingWorker (видеоурок, часть 15)
    Если вы занимаетесь программированием Swing (GUI) на Java, вы можете рассмотреть возможность использования класса SwingWorker для многопоточности. SwingWorker — это устрашающий, но полезный класс, который совершенен ….
    Многопоточность Java: прерывание потоков (видеоурок, часть 14)
    Что это за надоедливые исключения InterruptedException? В этом видео я покажу вам, как прерывать запущенные потоки в Java с помощью встроенного механизма прерывания потоков.После запуска видео нажмите ….
    Java Multithreading: Callable and Future (Видеоурок, часть 13)
    Как использовать Callable и Future в Java, чтобы получать результаты от ваших потоков и позволять вашим потокам генерировать исключения. Кроме того, Future позволяет вам контролировать свои потоки, проверяя, не .
    Многопоточность Java: семафоры (видеоурок, часть 12)
    Учебник по семафорам в Java.Семафоры в основном используются для ограничения количества одновременных потоков, которые могут получить доступ к ресурсам, но вы также можете использовать их для реализации систем восстановления тупиковых ситуаций ….
    Многопоточность Java: тупик (видеоурок, часть 11)
    Причины тупика и две вещи, которые вы можете с этим сделать. В этом видео также рассказывается, как написать метод, который может безопасно получить любое количество блокировок в любом порядке, не вызывая взаимоблокировки, с помощью команды try ….
    Многопоточность Java: блокировка повторного входа (видеоурок, часть 10)
    Как использовать класс ReentrantLock в Java в качестве альтернативы синхронизированным блокам кода.ReentrantLocks позволяет вам делать все, что вы можете делать с помощью synchronized, wait и notify, а также еще несколько . ..
    Многопоточность Java: низкоуровневый производитель-потребитель (видеоурок, часть 9)
    В этом руководстве мы рассмотрим, как реализовать шаблон производитель-потребитель с использованием низкоуровневых методов; а именно ждать, уведомлять и синхронизировать. Это не лучший способ реализовать продюсер-c ….
    Многопоточность Java: ожидание и уведомление (видеоурок, часть 8)
    Учебное пособие по ожиданию и уведомлению в Java; низкоуровневые многопоточные методы класса Object, которые позволяют одному или нескольким потокам спать, только чтобы их разбудили другие потоки в нужный момент….
    Многопоточность Java: производитель-потребитель (видеоурок, часть 7)
    Учебное пособие о том, как реализовать шаблон производитель-потребитель в Java с помощью класса Java ArrayBlockingQueue. Производитель-Потребитель — это ситуация, когда один или несколько потоков создают элементы данных и .
    Многопоточность Java: защелки обратного отсчета (видеоурок, часть 6)
    Видеоурок по использованию превосходного класса Java CountDownLatch для синхронизации действий ваших потоков.После запуска видео нажмите кнопку развернуть, чтобы развернуть его в полноэкранном режиме и увидеть ….
    Многопоточность Java: пулы потоков (видеоурок, часть 5)
    Руководство по управлению несколькими потоками в Java с использованием пулов потоков. С помощью пулов потоков вы можете назначить целую группу потоков для работы с вашей очередью задач. После запуска видео нажмите ….
    Многопоточность Java: блокировка объектов (видеоурок, часть 4)
    Это четвертая часть нашего расширенного руководства по многопоточности Java.В этом уроке я покажу вам, как можно использовать несколько блокировок для ускорения сложного многопоточного кода, иногда значительно.
    Многопоточность Java: синхронизированная (видеоурок, часть 3)
    Это третья часть нашего расширенного руководства по многопоточности Java. В этом уроке мы рассмотрим использование ключевого слова synchronized для координации действий между потоками и предотвращения их ошибок в ea ….
    Java Multithreading: Volatile — Basic Thread Communication (Video Tutorial Part 2)
    Вторая часть расширенного учебника по многопоточности Java.В этом руководстве мы рассмотрим использование ключевого слова volatile для связи между потоками с помощью флагов. Мы также смотрим, почему потенциальные нас ….
    Многопоточность Java: запуск потоков (видеоурок, часть 1)
    Многопоточность кажется вам черным искусством? Это первая часть расширенного руководства Java по многопоточности, которое, надеюсь, поможет вам. В этом уроке мы рассмотрим два способа .. .

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

    Что такое многопоточность?

    Многопоточность — это функция Java , которая позволяет одновременно выполнять две или более частей программы для максимального использования ЦП.Каждая часть такой программы называется потоком. Итак, потоки — это легковесные процессы внутри процесса. … Start () вызывает метод run () объекта Thread.

    Каковы преимущества многопоточности?

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

    Почему мы используем потоки?

    Thread — это легкий процесс, который помогает выполнять задачи параллельно. потоков работают независимо и обеспечивают максимальное использование ЦП, тем самым повышая производительность ЦП. Threads , чтобы сделать приложение Java быстрее, выполняя несколько операций одновременно.

    Как работает многопоточность?

    Многопоточность Java позволяет выполнять несколько задач одновременно. Это возможно, потому что современные компьютеры имеют несколько процессоров (центральные процессоры — это мозг вашего компьютера, а их много!).Один ЦП может работать с в одном потоке за раз (если ваши ЦП не имеют гиперпоточности, и в этом случае он может обрабатывать два одновременно)

    Преимущества многопоточности:

    • Повышенная производительность за счет сокращения времени разработки
    • Упрощенное и оптимизированное кодирование программ
    • Импровизированная адаптивность графического интерфейса
    • Одновременное и параллельное выполнение задач
    • Лучшее использование кэш-памяти за счет использования ресурсов
    • Снижение затрат на обслуживание
    • Лучшее использование ресурсов ЦП

    Недостатки многопоточности:

    • Комплексные процессы отладки и тестирования
    • Служебное переключение контекста
    • Повышенная вероятность возникновения тупика
    • Повышенная сложность написания программы
    • Непредсказуемые результаты

    Создание потока в Java

    Есть два способа создать поток в Java:
    1) Расширяя класс Thread.

    Добавить комментарий

    Ваш адрес email не будет опубликован. Обязательные поля помечены *