ЧАСТЬ 1> НИТИ — Лучшие 80 вопросов и ответов на собеседования (подробное объяснение с программами)
Вопрос 61
class MyRunnable implements Runnable{
public void run(){
for(int i=0;i<3;i++){
System.out.println("i="+i+" ,ThreadName="+Thread.currentThread().getName());
}
}
}
public class MyClass {
public static void main(String...args){
MyRunnable runnable=new MyRunnable();
System.out.println("start main() method");
Thread thread1=new Thread(runnable);
Thread thread2=new Thread(runnable);
thread1.start();
thread2.start();
System.out.println("end main() method");
}
}
Ответ.
Поведение потоков непредсказуемо, потому что выполнение потоков зависит от планировщика потоков,
Сначала будет напечатан метод start main (), но после этого мы не сможем гарантировать порядок потоков thread1, thread2 и main thread, которые они могут запускать одновременно или последовательно, поэтому порядок метода end main () не будет гарантирован.
/*ВЫВОД
запустить метод main ()
метод end main ()
i = 0, ThreadName = Thread-0
i = 0, ThreadName = Thread-1
i = 1, ThreadName = Thread-0
i = 2, ThreadName = Thread-0
i = 1, ThreadName = Thread-1
i = 2, ThreadName = Thread-1
* /
Вопрос 62
class MyRunnable implements Runnable{
public void run(){
for(int i=0;i<3;i++){
System.out.println("i="+i+" ,ThreadName="+Thread.currentThread().getName());
}
}
}
public class MyClass {
public static void main(String...args) throws InterruptedException{
System.out.println("In main() method");
MyRunnable runnable=new MyRunnable();
Thread thread1=new Thread(runnable);
Thread thread2=new Thread(runnable);
thread1.start();
thread1.join();
thread2.start();
thread2.join();
System.out.println("end main() method");
}
}
Ответ. Мы используем метод join (), чтобы все потоки, которые начинались с main, заканчивались в том порядке, в котором они начинались, а также main должен заканчиваться последним. Другими словами, метод join () ожидал смерти этого потока.
/*ВЫВОД
В методе main ()
i = 0, ThreadName = Thread-0
i = 1, ThreadName = Thread-0
i = 2, ThreadName = Thread-0
i = 0, ThreadName = Thread-1
i = 1, ThreadName = Thread-1
i = 2, ThreadName = Thread-1
метод end main ()
* /
Вопрос 63
class MyRunnable implements Runnable {
public void run() {
try {
while (!Thread.currentThread().isInterrupted()) {
Thread.sleep(1000);
System.out.println("x");
}
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + " ENDED");
}
}
}
public class MyClass {
public static void main(String args[]) throws Exception {
MyRunnable obj = new MyRunnable();
Thread t = new Thread(obj, "Thread-1");
t.start();
System.out.println("press enter");
System.in.read();
t.interrupt();
}
}
Ответ. Сначала будет напечатано «нажать ввод», затем нить1 будет продолжать печатать x, пока не будет нажата кнопка ввода , после нажатия клавиши будет напечатан «Нить-1 ЗАВЕРШЕНА». System.in.read () заставляет основной поток переходить из режима ожидания в состояние ожидания (поток ожидает ввода пользователя)
/* ВЫХОД
нажмите Ввод
Икс
Икс
Икс
Икс
Нить-1 закончилась
* /
Вопрос 64
class MyRunnable implements Runnable{
public void run(){
synchronized (this) {
System.out.println("1 ");
try {
this.wait();
System.out.println("2 ");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class MyClass {
public static void main(String[] args) {
MyRunnable myRunnable=new MyRunnable();
Thread thread1=new Thread(myRunnable,"Thread-1");
thread1.start();
}
}
Ответ. Поток получает блокировку для объекта myRunnable, поэтому 1 было напечатано, но notify не было вызвано, поэтому 2 никогда не будет напечатано, это называется замороженным процессом. Формируется тупик. Этот тип тупиков называется замороженными процессами.
/*ВЫВОД
1
* /
Вопрос 65
import java.util.ArrayList;
/* Producer is producing, Producer will allow consumer to
* consume only when 10 products have been produced (i.e. when production is over).
*/
class Producer implements Runnable{
ArrayList<Integer> sharedQueue;
Producer(){
sharedQueue=new ArrayList<Integer>();
}
@Override
public void run(){
synchronized (this) {
for(int i=1;i<=3;i++){ //Producer will produce 10 products
sharedQueue.add(i);
System.out.println("Producer is still Producing, Produced : "+i);
try{
Thread.sleep(1000);
}catch(InterruptedException e){e.printStackTrace();}
}
System.out.println("Production is over, consumer can consume.");
this.notify();
}
}
}
class Consumer extends Thread{
Producer prod;
Consumer(Producer obj){
prod=obj;
}
public void run(){
synchronized (this.prod) {
System.out.println("Consumer waiting for production to get over.");
try{
this.prod.wait();
}catch(InterruptedException e){e.printStackTrace();}
}
int productSize=this.prod.sharedQueue.size();
for(int i=0;i<productSize;i++)
System.out.println("Consumed : "+ this.prod.sharedQueue.remove(0) +" ");
}
}
public class MyClass {
public static void main(String args[]) throws InterruptedException{
Producer prod=new Producer();
Consumer cons=new Consumer(prod);
Thread prodThread=new Thread(prod,"prodThread");
Thread consThread=new Thread(cons,"consThread");
consThread.start();
Thread.sleep(100); //minor delay.
prodThread.start();
}
}
Ответ. Из-за небольшой задержки задержка consThread обязательно запускается перед потоком производителя. «Потребитель ждет, когда производство закончится». напечатан первым
чем продюсер
чем «Производство закончено, потребитель может потреблять».
чем потребитель потребляется.
Приведенная выше программа является классическим примером того, как решить проблему Consumer Producer с помощью методов wait () и notify () .
/*ВЫВОД
Потребитель ждет производства, чтобы закончить.
Продюсер все еще продюсирует, продюсеров: 1
Продюсер все еще продюсирует, продюсеров: 2
Продюсер все еще продюсирует, продюсеров: 3
Производство закончено, потребитель может потреблять.
Потреблено: 1
Потреблено: 2
Потреблено: 3
* /
Вопрос 66
class MyRunnable implements Runnable{
public void run(){
synchronized (this) {
System.out.print("1 ");
try {
this.wait(1000);
System.out.print("2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class MyClass {
public static void main(String[] args) {
MyRunnable myRunnable=new MyRunnable();
Thread thread1=new Thread(myRunnable,"Thread-1");
thread1.start();
}
}
Ответ. Первая 1 будет напечатана, затем, даже если notify () или notifyAll () не вызваны, поток будет уведомлен после 1000 миллисекунд, а 2 будет напечатано.
/*ВЫВОД
1 2
* /
Вопрос 67
class MyRunnable implements Runnable {
public void run() {
System.out.println(Thread.currentThread().getName() + " has started");
try {
Thread.sleep(100); //ensure that main thread don’t complete before Thread-1
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " has ended");
}
}
public class MyClass {
public static void main(String... args) throws InterruptedException {
System.out.println(Thread.currentThread().getName() + " has started");
Thread thread1 = new Thread(new MyRunnable(), "Thread-1");
thread1.start();
thread1.sleep(10000);
System.out.println(Thread.currentThread().getName() + " has ended");
}
}
Ответ.
sleep () — это статический метод, заставляющий текущий выполняющийся поток спать в течение указанного количества миллисекунд.
Callingthread1.sleep (10000); будет показывать предупреждение — Статический метод sleep (long) из типа Thread должен быть доступен статическим способом.
В программе сначала запустился основной поток, затем он вызвал Thread-1, затем Thread-1 вызвал метод sleep (100), чтобы основной поток не завершился до Thread-1, после чего управление выполнением перешло к основному потоку и вызвало thread1. sleep (10000), но вместо того, чтобы ставить Thread-1 в сон, он заставлял основной поток спать. И Нить-1 закончилась раньше основной нити.
/*ВЫВОД
главное началось
Тема 1 запущена
Тема-1 закончилась
основное закончилось
* /
Вопрос 68
class MyRunnable1 implements Runnable{
@Override
public void run(){
synchronized (this) {
try{
System.out.print("2 ");
Thread.sleep(1000);
}catch(InterruptedException e){e.printStackTrace();}
this.notify();
System.out.print("3 ");
}
}
}
class MyRunnable2 extends Thread{
MyRunnable1 prod;
MyRunnable2(MyRunnable1 obj){
prod=obj;
}
public void run(){
synchronized (this.prod) {
System.out.print("1 ");
try{
this.prod.wait();
}catch(InterruptedException e){e.printStackTrace();}
}
System.out.print("4 ");
}
}
public class MyClass {
public static void main(String args[]) throws InterruptedException{
MyRunnable1 myRunnable1=new MyRunnable1();
MyRunnable2 myRunnable2=new MyRunnable2(myRunnable1);
Thread thread1=new Thread(myRunnable1,"Thread-1");
Thread thread2=new Thread(myRunnable2,"Thread-2");
thread2.start();
Thread.sleep(100); //This minor delay will ensure that Thread-1 thread starts Thread-2
thread1.start();
}
}
Ответ. Метод Wait () заставляет текущий поток ждать, пока другой поток не вызовет метод notify () или notifyAll () для этого объекта.
Теперь, как только вызывается метод notify () или notifyall (), он уведомляет ожидающий поток, но объектный монитор еще не доступен. Монитор объектов доступен только тогда, когда поток выходит из синхронизированного блока или синхронизированного метода. Итак, что происходит, так это то, что код после notify () также выполняется и выполняется до тех пор, пока мы не достигнем конца синхронизированного блока.
/*ВЫВОД
1 2 3 4
* /
Вопрос 69
class MyThread extends Thread {
MyThread() {
System.out.print("1 ");
}
public void run() {
System.out.print("2 ");
}
}
public class MyClass {
public static void main(String[] args) {
Thread thread1 = new MyThread() {
public void run() {
System.out.print("3 ");
}
};
thread1.start();
}
}
Ответ.
new MyThread ()> создал экземпляр анонимного внутреннего класса.
конструктор был назван который напечатан 1
чем был переопределен метод run () анонимного внутреннего класса, который вывел 3.
/*ВЫВОД
1 3
* /
Вопрос 70
class MyRunnable implements Runnable{
public void run(){
method();
}
synchronized void method(){
for(int i=0;i<2;i++){
System.out.println(Thread.currentThread().getName());
}
}
}
public class MyClass {
public static void main(String...args){
MyRunnable runnable=new MyRunnable();
Thread thread1=new Thread(runnable,"Thread-1");
Thread thread2=new Thread(runnable,"Thread-2");
thread1.start();
thread2.start();
}
}
Ответ. Поведение потока непредсказуемо, потому что выполнение Thread-ов зависит от планировщика Thread-а, либо thread1 и thread2 могут запускаться первыми, а синхронизированный метод будет выполняться по одному потоку за раз .
/ * OUTPUT, если Thread-1 вошел первым в синхронизированный блок.
Thread-1
Thread-1
Thread-2
Thread-2
* /
/ * OUTPUT, если Thread-2 вошел первым в синхронизированный блок.
Thread-2
Thread-2
Thread-1
Thread-1
* /
Вопрос 71
public class MyClass {
public static void main(String[] args) {
Thread thread1=new Thread("Thread-1"){
public void run() {
synchronized (String.class) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {e.printStackTrace();}
System.out.println("1 ");
synchronized (Object.class) {
System.out.println("2 ");
}
}
System.out.println("3 ");
}
};
Thread thread2=new Thread("Thread-2"){
public void run() {
synchronized (Object.class) {
System.out.println("4 ");
try {
Thread.sleep(100);
} catch (InterruptedException e) {e.printStackTrace();}
synchronized (String.class) {
System.out.println("5 ");
}
}
System.out.println("6 ");
}
};
thread1.start();
thread2.start();
}
}
Ответ. Тупик формируется в вышеуказанной программе:
Thread-1 получает блокировку для String.class и затем вызывает метод sleep (), который дает Thread-2 возможность выполнить сразу после того, как Thread-1 установил блокировку для String.class, а Thread-2 получает блокировку для Object.class, а затем вызывает sleep () и теперь он ожидает, пока Thread-1 снимет блокировку с String.class.
Вывод:
Теперь Thread-1 ожидает, пока Thread-2 снимет блокировку с Object.class, а Thread-2 ожидает, пока Thread-1 снимет блокировку с String.class, и возникнет взаимоблокировка .
/*ВЫВОД
4
1
* /
Вопрос 72
public class MyClass {
public static void main(String[] args) throws InterruptedException {
synchronized (args) {
System.out.print("1 ");
args.wait();
System.out.print("2 ");
}
}
}
Ответ. Хотя этот вопрос выглядит немного похожим на 4, но намерение показать, что args является объектом, и мы можем зафиксировать его.
Поток получает блокировку на объекте args, но notify не был вызван, поэтому 2 никогда не будет напечатано, это называется замороженным процессом.
/*ВЫВОД
1
* /
Вопрос 73
class Class2 {
void method2(String name) {
for (int x = 1; x <=2; x++) {
System.out.println(Thread.currentThread().getName());
}
}
}
public class MyClass implements Runnable {
Class2 obj2;
public static void main(String[] args) {
new MyClass().method1();
}
void method1() {
obj2 = new Class2();
new Thread(new MyClass()).start();
new Thread(new MyClass()).start();
}
public void run() {
obj2.method2(Thread.currentThread().getName());
}
}
Ответ. Программа столкнется с NullPointerException на Class2 obj2, мы должны сделать его статическим. Как новый поток (новый MyClass ()). Start (); создает поток на новом экземпляре MyClass.
Если Class2 obj2 сделан статическим, тогда
Нить-0 и Нить-1 будут напечатаны дважды, но в непредсказуемом порядке.
Таким образом, вывод будет отличаться в последующих исполнениях (как показано ниже) —
/*ВЫВОД
Thread-1
Thread-1
Резьбонарезной 0
Резьбонарезной 0
* /
/*ВЫВОД
Резьбонарезной 0
Thread-1
Thread-1
Резьбонарезной 0
* /
Вопрос 74.
class MyRunnable1 implements Runnable{
@Override
public void run(){
if(Thread.currentThread().getName().equals("Thread-1"))
method1();
else
method2();
}
synchronized void method1(){
System.out.println(Thread.currentThread().getName()
+" in synchronized void method1() started");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+" in synchronized void method1() ended");
}
synchronized void method2(){
System.out.println(Thread.currentThread().getName()
+" in synchronized void method2() started");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
" in synchronized void method2() ended");
}
}
public class MyClass {
public static void main(String args[]) throws InterruptedException{
MyRunnable1 myRunnable1=new MyRunnable1();
Thread thread1=new Thread(myRunnable1,"Thread-1");
Thread thread2=new Thread(myRunnable1,"Thread-2");
thread1.start();
Thread.sleep(10);//Just to ensure Thread-1 starts before Thread-2
thread2.start();
}
}
Ответ. Здесь, когда Thread-1 находится в синхронизированном методе1 (), он должен удерживать блокировку на мониторе объекта и снимать блокировку на мониторе объекта только при выходе из синхронизированного метода 1 (). Итак, Thread-2 должен будет дождаться, пока Thread-1 снимет блокировку на мониторе объекта, чтобы он мог войти в synchronized method2 ().
Аналогично, Thread-2 даже не может войти в синхронизированный метод method1 (), который выполняется Thread-1. Поток-2 должен будет ждать, пока Поток-1 снимет блокировку на мониторе объекта, чтобы он мог войти в synchronized method1 ().
/*ВЫВОД
Поток-1 в синхронизированном void method1 () запущен
Поток-1 в синхронизированном void method1 () завершен
Поток 2 в синхронизированном void method2 () запущен
Поток 2 в синхронизированном void method2 () завершен
* /
Вопрос 75
class MyRunnable implements Runnable{
public void run(){
System.out.println("1 ");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("2 ");
}
}
public class WaitNoParaMethod {
public static void main(String[] args) {
MyRunnable myRunnable=new MyRunnable();
Thread thread1=new Thread(myRunnable,"Thread-1");
thread1.start();
}
}
Ответ.
IllegalMonitorStateException генерируется во время выполнения, так как метод wait () был вызван без получения блокировки на мониторе объекта.
/*ВЫВОД
1
Исключение в потоке «Thread-1» java.lang.IllegalMonitorStateException
в java.lang.Object.wait (родной метод)
в java.lang.Object.wait (Object.java:503)
в o15_wait_IllegalMoni.MyRunnable.run (WaitNoParaMethod.java:9)
at java.lang.Thread.run (неизвестный источник)
* /
Вопрос 76
public class MyClass implements Runnable{
@Override
public void run() {
System.out.println("1");
}
public static void main(String[] args) {
MyClass obj=new MyClass();
Thread thread1=new Thread(obj,"Thread-1");
thread1.start();
thread1.start();
}
}
Ответ. мы не можем запустить Thread снова , это вызовет исключение runtimeException java.lang.IllegalThreadStateException. Причина в том, что когда-то метод run () выполняется Thread, он переходит в мертвое состояние .
Давайте возьмем пример
Думать о том, чтобы снова запустить поток и вызвать для него метод start () (который внутренне будет вызывать метод run ()), это то же самое, что попросить мертвого человека проснуться и запустить. Как и после завершения своей жизни человек переходит в мертвое состояние.
/*ВЫВОД
1
Исключение в потоке «main» java.lang.IllegalThreadStateException
на java.lang.Thread.start (неизвестный источник)
* /
Вопрос 77
class MyThread extends Thread {
}
public class MyClass {
public static void main(String[] args) {
Thread thread1=new MyThread();
thread1.start();
}
}
Ответ. Ничего не будет напечатано на выходе.
Когда мы вызываем метод start () для потока, он внутренне вызывает метод run () для вновь созданного потока. Поэтому, если мы не переопределим метод run (), вновь созданный поток не будет вызываться и ничего не произойдет.
Вопрос 78
class MyThread extends Thread {
public void run() {
System.out.println("1");
}
public void start(){
System.out.println("2");
}
}
public class MyClass {
public static void main(String[] args) {
MyThread thread1=new MyThread();
thread1.start();
}
}
Ответ. Когда мы вызываем метод start () в потоке, он внутренне вызывает метод run () для вновь созданного потока. Таким образом, если мы переопределим метод start (), метод run () не будет вызываться, пока мы не напишем код для вызова метода run ().
/*ВЫВОД
2
* /
Вопрос 79
class MyRunnable1 implements Runnable{
@Override
public void run(){
if(Thread.currentThread().getName().equals("Thread-1"))
method1();
else
method2();
}
static synchronized void method1(){
System.out.println(Thread.currentThread().getName()+
" in synchronized void method1() started");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+" in synchronized void method1() ended");
}
static synchronized void method2(){
System.out.println(Thread.currentThread().getName()
+" in synchronized void method2() started");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+" in synchronized void method2() ended");
}
}
public class MyClass {
public static void main(String args[]) throws InterruptedException{
MyRunnable1 object1=new MyRunnable1();
MyRunnable1 object2=new MyRunnable1();
Thread thread1=new Thread(object1,"Thread-1");
Thread thread2=new Thread(object2,"Thread-2");
thread1.start();
Thread.sleep(10);//Just to ensure Thread-1 starts before Thread-2
thread2.start();
}
}
Ответ. Вас может немного смущать, что потоки создаются на разных объектах. Но не стоит забывать, что может существовать несколько объектов, но всегда доступна блокировка объекта одного класса .
Здесь, когда Thread-1 находится в статическом синхронизированном method1 (), он должен удерживать блокировку объекта класса и снимать блокировку класса classobject только при выходе из статического синхронизированного метода1 (). Итак, Thread-2 должен будет дождаться, пока Thread-1 снимет блокировку с класса classobject, чтобы он мог войти в static synchronized method2 ().
/*ВЫВОД
Поток-1 в синхронизированном void method1 () запущен
Поток-1 в синхронизированном void method1 () завершен
Поток 2 в синхронизированном void method2 () запущен
Поток 2 в синхронизированном void method2 () завершен
* /
Вопрос 80
class MyRunnable1 implements Runnable{
@Override
public void run(){
if(Thread.currentThread().getName().equals("Thread-1"))
method1();
else
method2();
}
synchronized void method1(){
System.out.println(Thread.currentThread().getName()+
" in synchronized void method1() started");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
" in synchronized void method1() ended");
}
synchronized void method2(){
System.out.println(Thread.currentThread().getName()
+" in synchronized void method2() started");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+" in synchronized void method2() ended");
}
}
public class MyClass {
public static void main(String args[]) throws InterruptedException{
MyRunnable1 object1=new MyRunnable1();
MyRunnable1 object2=new MyRunnable1();
Thread thread1=new Thread(object1,"Thread-1");
Thread thread2=new Thread(object2,"Thread-2");
thread1.start();
Thread.sleep(10);//Just to ensure Thread-1 starts before Thread-2
thread2.start();
}
}
Ответ. Здесь, когда Thread-1 находится в синхронизированном method1 (), он должен удерживать блокировку на мониторе object1 . Поток-2 получит блокировку на мониторе объекта 2 и введет синхронизированный метод 2 ().
/*ВЫВОД
Поток-1 в синхронизированном void method1 () запущен
Поток 2 в синхронизированном void method2 () запущен
Поток-1 в синхронизированном void method1 () завершен
Поток 2 в синхронизированном void method2 () завершен
* /
Вопрос 81
public class MyClass extends Thread{
public void run() {
method1();
}
public static void method1() {
synchronized (this) {
System.out.println("2 ");
}
}
public static void main(String[] args) {
new Thread(new MyClass()).start();
}
}
Ответ. Мы столкнемся с ошибкой компиляции в линии, которую синхронизировать нельзя (это) нельзя использовать в статическом контексте, потому что невозможно получить блокировку объекта из статического метода. Хотя мы можем получить блокировку для объекта класса класса, синхронизированный (MyClass.class) будет допустимым утверждением.
Вопрос 82
public class MyClass {
public static void main(String[] args) {
System.out.println("1 ");
InnerClass i=new InnerClass();
i.start();
System.out.println("2 ");
}
static class InnerClass extends Thread{
public void run()throws RuntimeException{
throw new RuntimeException();
}
}
}
Ответ. Программа скомпилируется как метод run () может вызвать исключение RuntimeException. 1 и 2 будут присутствовать в выходных данных и вызовут исключение java.lang.RuntimeException во время выполнения.
/*ВЫВОД
1
2
Исключение в потоке «Thread-0» java.lang.RuntimeException
в o22.s $ InnerClass.run (s.java:13)
* /