Clase Java.lang.Thread en Java

Enhebre una línea de ejecución dentro de un programa. Cada programa puede tener múltiples hilos asociados. Cada subproceso tiene una prioridad que utiliza el programador de subprocesos para determinar qué subproceso debe ejecutarse primero. Java proporciona una clase de subprocesos que tiene varias llamadas a métodos para administrar el comportamiento de los subprocesos al proporcionar constructores y métodos para realizar operaciones en los subprocesos. 

Formas de crear hilos.

1. Creando una clase propia que se extiende a la clase Thread principal
2. Implementación de la interfaz Runnable.

A continuación se encuentran los pseudocódigos a los que se puede hacer referencia para obtener una mejor imagen sobre el subproceso de ahora en adelante Clase de subproceso.

Ilustración 1:

// Way 1
// Creating thread By Extending To Thread class
 
class MyThread extends Thread {
 
    // Method 1
    // Run() method for our thread
    public void run()
    {
 
        // Print statement
        System.out.println(
            "Thread is running created by extending to parent Thread class");
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating object of our thread class inside main()
        // method
        MyThread myThread = new MyThread();
       
        // Starting the thread
        myThread.start();
    }
}

Thread is running created by extending to parent Thread class

Ilustración 2:

// Way 2
// Creating thread using Runnable interface
 
class ThreadUsingInterface implements Runnable {
 
    // Method 1
    // run() method for the thread
    public void run()
    {
 
        // Print statement
        System.out.println("Thread is created using Runnable interface");
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating object of our thread class inside main()
        // method
        ThreadUsingInterface obj = new ThreadUsingInterface();
       
        // Passing the object to thread in main()
        Thread myThread = new Thread(obj);
       
        // Starting the thread
        myThread.start();
    }
}

Thread is created using Runnable interface

Clase de hilo en Java 

Un hilo es un programa que comienza con un método() que se usa con frecuencia en esta clase y que solo se conoce como el método de inicio(). Este método busca el método run() que también es un método de esta clase y comienza a ejecutar el cuerpo del método run(). aquí vigile el método sleep() que se discutirá más adelante.

Nota: cada clase que se usa como subproceso debe implementar la interfaz Runnable y anular su método de ejecución.

Sintaxis: 

public class Thread extends Object implements Runnable

Los constructores de esta clase son los siguientes:

Métodos de la clase Thread:

Ahora analicemos todos los métodos de esta clase que se ilustran a continuación:

También recuerde que hay ciertos métodos heredados de la clase Java. lang.Object que son los siguientes: 

1. método igual() 
2. Método finalizar() 
3. método getClass() 
4. Método hashCode() 
5. método de notificación() 
6. Método de notificación a todos() 
7. Método toString()
8. método esperar()

Ejemplo: programa Java para demostrar el uso de la clase Thread 

// Java program Demonstrating Methods of Thread class
 
// Importing package
package generic;
 
// Class 1
// Helper class implementing Runnable interface
class Helper implements Runnable {
 
    //
    public void run() {
 
        // Try block to check for exceptions
        try {
 
            // Print statement
            System.out.println("thread2 going to sleep for 5000");
 
            // Making thread sleep for 0.5 seconds
            Thread.sleep(5000);
 
        }
 
        // Catch block to handle exception
        catch (InterruptedException e) {
 
            // Print statement
            System.out.println("Thread2 interrupted");
        }
    }
}
 
// Class 2
// Helper class extending Runnable interface
public class Test implements Runnable {
 
    // Method 1
    // run() method of this class
    public void run() {
 
        // Thread run() method
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args) {
 
        // Making objects of class 1 and 2 in main() method
        Test obj = new Test();
        Helper obj2 = new Helper();
 
        // Creating 2 threads in main() method
        Thread thread1 = new Thread(obj);
        Thread thread2 = new Thread(obj2);
 
        // Moving thread to runnable states
        thread1.start();
        thread2.start();
 
        // Loading thread 1 in class 1
        ClassLoader loader = thread1.getContextClassLoader();
 
        // Creating 3rd thread in main() method
        Thread thread3 = new Thread(new Helper());
 
        // Getting number of active threads
        System.out.println(Thread.activeCount());
        thread1.checkAccess();
 
        // Fetching an instance of this thread
        Thread t = Thread.currentThread();
 
        // Print and display commands
        System.out.println(t.getName());
 
        System.out.println("Thread1 name: " + thread1.getName());
        System.out.println("Thread1 ID: " + thread1.getId());
 
        // Fetching the priority and state of thread1
        System.out.println("Priority of thread1 = " + thread1.getPriority());
 
        // Getting the state of thread 1 using getState() method
        // and printing the same
        System.out.println(thread1.getState());
 
        thread2 = new Thread(obj2);
        thread2.start();
        thread2.interrupt();
        System.out.println("Is thread2 interrupted? " + thread2.interrupted() );
        System.out.println("Is thread2 alive? " + thread2.isAlive());
 
        thread1 = new Thread(obj);
        thread1.setDaemon(true);
        System.out.println("Is thread1 a daemon thread? " + thread1.isDaemon());
        System.out.println("Is thread1 interrupted? " + thread1.isInterrupted());
 
        // Waiting for thread2 to complete its execution
        System.out.println("thread1 waiting for thread2 to join");
 
        try {
            thread2.join();
        }
 
        catch (InterruptedException e) {
 
            // Display the exception along with line number
            // using printStackTrace() method
            e.printStackTrace();
        }
 
        // Now setting the name of thread1
        thread1.setName("child thread xyz");
 
        // Print and display command
        System.out.println("New name set for thread 1" + thread1.getName());
 
        // Setting the priority of thread1
        thread1.setPriority(5);
 
        thread2.yield();
 
        // Fetching the string representation of thread1
        System.out.println(thread1.toString());
 
        // Getting list of active thread in current thread's group
        Thread[] tarray = new Thread[3];
 
        Thread.enumerate(tarray);
 
        // Display commands
        System.out.println("List of active threads:");
        System.out.printf("[");
 
        // Looking out using for each loop
        for (Thread thread : tarray) {
 
            System.out.println(thread);
        }
 
        // Display commands
        System.out.printf("]\n");
 
        System.out.println(Thread.getAllStackTraces());
 
        ClassLoader classLoader = thread1.getContextClassLoader();
        System.out.println(classLoader.toString());
        System.out.println(thread1.getDefaultUncaughtExceptionHandler());
 
        thread2.setUncaughtExceptionHandler(thread1.getDefaultUncaughtExceptionHandler());
        thread1.setContextClassLoader(thread2.getContextClassLoader());
        thread1.setDefaultUncaughtExceptionHandler(thread2.getUncaughtExceptionHandler());
 
        thread1 = new Thread(obj);
        StackTraceElement[] trace = thread1.getStackTrace();
 
        System.out.println("Printing stack trace elements for thread1:");
 
        for (StackTraceElement e : trace) {
            System.out.println(e);
        }
 
        ThreadGroup grp = thread1.getThreadGroup();
        System.out.println("ThreadGroup to which thread1 belongs " + grp.toString());
        System.out.println(thread1.getUncaughtExceptionHandler());
        System.out.println("Does thread1 holds Lock? " + thread1.holdsLock(obj2));
 
 
        Thread.dumpStack();
 
    }
}

Producción: 

3
main
Thread1 name: Thread-0
Thread1 ID: 10
Priority of thread1 = 5
RUNNABLE
Is thread2 interrupted? false
Is thread2 alive? true
Is thread1 a daemon thread? true
Is thread1 interrupted? false
thread1 waiting for thread2 to join
thread2 going to sleep for 5000 ms
thread2 going to sleep for 5000 ms
Thread2 interrupted
New name set for thread 1child thread xyz
Thread[child thread xyz, 5, main]
List of active threads:
[Thread[main, 5, main]
Thread[Thread-1, 5, main]
null
]
{Thread[Signal Dispatcher, 9, system]=[Ljava.lang.StackTraceElement;@33909752, 
Thread[Thread-1, 5, main]=[Ljava.lang.StackTraceElement;@55f96302, 
Thread[main, 5, main]=[Ljava.lang.StackTraceElement;@3d4eac69, 
Thread[Attach Listener, 5, system]=[Ljava.lang.StackTraceElement;@42a57993, 
Thread[Finalizer, 8, system]=[Ljava.lang.StackTraceElement;@75b84c92, 
Thread[Reference Handler, 10, system]=[Ljava.lang.StackTraceElement;@6bc7c054}
sun.misc.Launcher$AppClassLoader@73d16e93
null
Printing stack trace elements for thread1:
ThreadGroup to which thread1 belongs java.lang.ThreadGroup[name=main, maxpri=10]
java.lang.ThreadGroup[name=main, maxpri=10]
Does thread1 holds Lock? false
java.lang.Exception: Stack trace
    at java.lang.Thread.dumpStack(Unknown Source)
    at generic.Test.main(Test.java:111) 

Este artículo es una contribución de Mayank Kumar . 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.