Hilo principal en Java

Java proporciona soporte integrado para la programación multiproceso. Un programa de subprocesos múltiples contiene dos o más partes que pueden ejecutarse simultáneamente. Cada parte de un programa de este tipo se denomina subproceso, y cada subproceso define una ruta de ejecución separada.
Cuando se inicia un programa Java, un subproceso comienza a ejecutarse inmediatamente. Este suele llamarse hilo principal de nuestro programa porque es el que se ejecuta cuando se inicia nuestro programa. 

Hay ciertas propiedades asociadas con el hilo principal que son las siguientes:

• Es el subproceso del que se generarán otros subprocesos «secundarios».
• A menudo, debe ser el último subproceso en finalizar la ejecución porque realiza varias acciones de apagado.

El diagrama de flujo es el siguiente:

Cómo controlar el hilo principal

El hilo principal se crea automáticamente cuando se inicia nuestro programa. Para controlarlo debemos obtener una referencia al mismo. Esto se puede hacer llamando al método subproceso actual() que está presente en la clase Subproceso. Este método devuelve una referencia al subproceso en el que se llama. La prioridad predeterminada del subproceso principal es 5 y para todos los subprocesos de usuario restantes, la prioridad se heredará de padre a hijo.

Ejemplo

// Java program to control the Main Thread
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Class 1
// Main class extending thread class
public class Test extends Thread {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Getting reference to Main thread
        Thread t = Thread.currentThread();
 
        // Getting name of Main thread
        System.out.println("Current thread: "
                           + t.getName());
 
        // Changing the name of Main thread
        t.setName("Geeks");
        System.out.println("After name change: "
                           + t.getName());
 
        // Getting priority of Main thread
        System.out.println("Main thread priority: "
                           + t.getPriority());
 
        // Setting priority of Main thread to MAX(10)
        t.setPriority(MAX_PRIORITY);
 
        // Print and display the main thread priority
        System.out.println("Main thread new priority: "
                           + t.getPriority());
 
        for (int i = 0; i < 5; i++) {
            System.out.println("Main thread");
        }
 
        // Main thread creating a child thread
        Thread ct = new Thread() {
            // run() method of a thread
            public void run()
            {
 
                for (int i = 0; i < 5; i++) {
                    System.out.println("Child thread");
                }
            }
        };
 
        // Getting priority of child thread
        // which will be inherited from Main thread
        // as it is created by Main thread
        System.out.println("Child thread priority: "
                           + ct.getPriority());
 
        // Setting priority of Main thread to MIN(1)
        ct.setPriority(MIN_PRIORITY);
 
        System.out.println("Child thread new priority: "
                           + ct.getPriority());
 
        // Starting child thread
        ct.start();
    }
}
 
// Class 2
// Helper class extending Thread class
// Child Thread class
class ChildThread extends Thread {
 
    @Override public void run()
    {
 
        for (int i = 0; i < 5; i++) {
 
            // Print statement whenever child thread is
            // called
            System.out.println("Child thread");
        }
    }
}

Current thread: main
After name change: Geeks
Main thread priority: 5
Main thread new priority: 10
Main thread
Main thread
Main thread
Main thread
Main thread
Child thread priority: 10
Child thread new priority: 1
Child thread
Child thread
Child thread
Child thread
Child thread

Ahora analicemos la relación entre el método main() y el subproceso principal en Java. Para cada programa, JVM (Java Virtual Machine) crea un subproceso principal. El subproceso «Principal» primero verifica la existencia del método main() y luego inicializa la clase. Tenga en cuenta que a partir de JDK 6, el método main() es obligatorio en una aplicación java independiente.

Interbloqueo con el uso del subproceso principal (solo subproceso único)

Podemos crear un interbloqueo simplemente usando el subproceso principal, es decir, usando solo un subproceso.

Ejemplo

// Java program to demonstrate deadlock
// using Main thread
 
// Main class
public class GFG {
 
  // Main driver method
  public static void main(String[] args) {
 
    // Try block to check for exceptions
    try {
 
      // Print statement
      System.out.println("Entering into Deadlock");
 
      // Joining the current thread
      Thread.currentThread().join();
 
      // This statement will never execute
      System.out.println("This statement will never execute");
    }
 
    // Catch block to handle the exceptions
    catch (InterruptedException e) {
 
      // Display the exception along with line number
      // using printStackTrace() method
      e.printStackTrace();
    }
  }
}

Producción: 

Explicación de la salida: 
la instrucción «Thread.currentThread().join()», le indicará al subproceso principal que espere a que este subproceso (es decir, se espere a sí mismo) muera. Por lo tanto, el hilo principal espera a que muera, lo que no es más que un punto muerto.

Artículo relacionado: Daemon Threads en Java .
Este artículo es una contribución de Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@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.