Salida del programa Java | Juego 16 (Hilos)

Prerrequisitos: subprocesamiento múltiple en java , ciclo de vida y estados de un subproceso , unión de subprocesos en java , método start() en java
1) ¿Cuál podría ser el resultado del siguiente programa?

public class Test implements Runnable
{
    public void run()
    {
        System.out.printf("GFG ");
        System.out.printf("Geeks ");
    }
    public static void main(String[] args)
    {
        Test obj = new Test();
        Thread thread = new Thread(obj);
          
        thread.start();
        System.out.printf("Geeks ");
        try 
        {
            thread.join();
        } 
        catch (InterruptedException e) 
        {
            e.printStackTrace();
        }
        System.out.println("for ");
    }
}

a) GFG Geeks Geeks para
b) Geeks GFG Geeks para
c) Ya sea a o b
d) Tanto a como b juntos

Respuesta (c)
Explicación: A partir de la sentencia “thread.start()”, tenemos dos hilos Main thread y “thread” thread. Por lo tanto, se puede imprimir «GFG» o «Geeks», según el hilo, el cronograma del programador de hilos.
Para (a), el subproceso principal después de llamar al método start() se detiene y el programador del subproceso programa el subproceso secundario que luego completa su ejecución. Después de esto, se programa el subproceso principal. Para (b), el subproceso principal llama al método start() pero continúa su ejecución e imprime en la consola. Cuando se llama al método join(), el subproceso principal tiene que esperar a que su hijo complete su ejecución. El programador de subprocesos programa el subproceso secundario mientras el padre espera a que el hijo se complete.

2) ¿Cuál es la salida del siguiente programa?

public class Test implements Runnable
{
    public void run()
    {
        System.out.printf("GFG ");
    }
    public static void main(String[] args) throws InterruptedException
    {
        Thread thread1 = new Thread(new Test());
        thread1.start();
        thread1.start();
        System.out.println(thread1.getState());
    }
}

a) GFG GFG TERMINADO
b) GFG TERMINADO
c) Error de compilación
d) Error de tiempo de ejecución

Respuesta (d)
Explicación: La invocación del método start() en un subproceso mueve el subproceso a un estado EJECUTABLE. Pero al invocar el método start() en un subproceso que ya comenzó, se genera una IllegalThreadStateException porque el subproceso ya se encuentra en estado EJECUTABLE.

3) ¿Cuál es la salida del siguiente programa?

public class Test extends Thread implements Runnable
{
    public void run()
    {
        System.out.printf("GFG ");
    }
    public static void main(String[] args) throws InterruptedException
    {
        Test obj = new Test();
        obj.run();
        obj.start();
    }
}

a) Error de tiempo de ejecución
b) Error de compilación
c) GFG GFG
d) Ninguna de las anteriores
Resp. (c)
Explicación: la clase Test amplía la clase Thread que tiene implementado el método start(). Entonces, invocar start() en un objeto que extiende la clase Thread invoca el método run() definido en el programa.

4) ¿Cuál es la salida del siguiente programa?

class myThread implements Runnable
{
    public void run()
    {
        Test.obj.notify();
    }
}
  
public class Test implements Runnable
{
    public static Test obj;
    private int data;
    public Test()
    {
        data = 10;
    }
    public void run()
    {
        obj = new Test();
        obj.wait();
        obj.data += 20;
          
        System.out.println(obj.data);
    }
    public static void main(String[] args) throws InterruptedException
    {
        Thread thread1 = new Thread(new Test());
        Thread thread2 = new Thread(new myThread());
          
        thread1.start();
        thread2.start();
      
        System.out.printf(" GFG - ");   
    }
}

a) 30 GFG –
b) GFG – 30
c) GFG –
d) Error de compilación

Respuesta (d)
Explicación: un objeto primero debe adquirir un bloqueo antes de llamar al método wait(). También el método wait() lanza la excepción Checked (InterruptedException), debemos incluirla en un bloque try-catch o lanzarla.

5) ¿Cuál es el resultado del siguiente programa?

import java.util.concurrent.*;
  
public class Test implements Runnable
{
    public static CyclicBarrier barrier = new CyclicBarrier(3);
    public void run()
    {
        System.out.printf(" GFG ");
        try 
        {
            barrier.await();
        } catch (InterruptedException | BrokenBarrierException e) 
        {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws InterruptedException
    {
        Thread thread1 = new Thread(new Test());
        Thread thread2 = new Thread(new Test());
          
        thread1.start();
        thread2.start();
        System.out.printf(" GeeksforGeeks ");
        try 
        {
            barrier.await();
        } catch (InterruptedException | BrokenBarrierException e) 
        {
            e.printStackTrace();
        }
        System.out.printf(" End ");
          
    }
}

a) GeeksforGeeks GFG GFG End
b) GFG GeeksforGeeks GFG End
c) GFG GFG GeeksforGeeks End
d) Todas las anteriores

Respuesta (d)
Explicación: para (a), el subproceso principal sigue ejecutándose hasta que alcanza la barrera. A continuación, se programan los subprocesos secundarios. Para (b), programador de subprocesos programador subproceso1. Una vez que alcanza la barrera, se programa el subproceso principal. Una vez que el subproceso principal alcanza la barrera, se programa el subproceso2. Para (c), ambos subprocesos secundarios están programados. Finalmente, cuando cada uno de los subprocesos secundarios alcanza la barrera, se programa el subproceso principal.

Este artículo es una contribución de Mayank Kumar . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.