Java de programación multi-hilo

Java de programación multi-hilo para proporcionar soporte incorporado. Un programa de multiproceso contiene dos o más porciones pueden ejecutarse simultáneamente. Cada parte del programa se denomina un hilo, y cada hilo define una trayectoria separada de la ejecución.

Multihilo es una forma especial de la multitarea, multihilo, pero el uso de una sobrecarga de recursos más pequeña.

Otro término se define en el presente documento, y relacionado con el hilo - proceso: un proceso que incluye el sistema operativo asigna espacio de memoria que contiene uno o más hilos. Un hilo separado no puede existir, debe ser parte del proceso. Un proceso ha estado funcionando hasta el final de todos los no espera hasta después del final de la rosca se ejecute.

Multihilo puede cumplir con los programadores escribir programas eficientes para alcanzar los propósitos de utilización de CPU completos.

ciclo de vida de un hilo

Hilo a través de todas las etapas de su ciclo de vida. La siguiente figura muestra el ciclo de vida completo de un hilo.

• Nueva Estado:

  Después de utilizar la nueva palabra clave y la clase o subclase de rosca para crear un objeto hilo, el hilo es objeto de un nuevo estado. Permanece en este estado hasta que el inicio del programa () este hilo.

• estado de lista:

  Cuando un objeto hilo para llamar al método start (), el hilo en el estado preparado. hilo listo en la cola de preparados, para esperar a que la programación programador de subprocesos JVM.

• Estado de funcionamiento:

  Si el hilo se pone estado de lista de recursos de CPU, puede realizar run (), el hilo se ejecuta en este momento. Hilo conductor a los más complejos, puede convertirse en estado bloqueado, estado preparado, y el estado de la muerte.

• estado bloqueado:

  Si un hilo se ejecuta después del sueño (sueño), suspender (se bloquea) y otros métodos, la pérdida de recursos ocupados, el hilo entra en el estado bloqueado se ejecute. Después de que ha llegado el tiempo de sueño para conseguir el equipo o los recursos para volver a entrar en el estado listo.

• Estado de la muerte:

  Cuando se produce un hilo de estado de la tarea u otra condición de terminación en funcionamiento, el hilo se conmuta al estado final.

La prioridad de un hilo

Cada hilo de Java tiene una prioridad, lo que ayuda a determinar el orden de programación de hilos del sistema operativo.

La prioridad de hebra Java es un número entero que va de 1 (Thread.MIN_PRIORITY) - 10 (Thread.MAX_PRIORITY).

De forma predeterminada, cada hilo se le asigna una prioridad NORM_PRIORITY (5).

Hilo con una prioridad más alta es más importante para el programa, y ​​debería asignar los recursos del procesador antes de hilos de baja prioridad. Sin embargo, la orden no garantiza hilo de rosca de prioridad de ejecución, y es muy dependiente de la Internet.

Crear un hilo

Java proporciona dos métodos para crear un hilo:

• Runable implementando la interfaz;
• A través de herencia misma clase Thread.

Para crear un hilo mediante la implementación de la interfaz Ejecutable

Crear un hilo, la forma más fácil es crear una clase que implementa la interfaz Ejecutable.

Con el fin de lograr Ejecutable, una clase solo necesita realizar una llamada al método run (), la siguiente declaración:

public void run()

Puede reemplazar este método, es importante entender el run () se puede llamar a otros métodos, el uso de otras clases, y declarar una variable, al igual que el hilo principal.

Después de crear una clase implementa la interfaz Ejecutable, se puede crear una instancia de un objeto en la clase de un hilo.

Hilo define varios constructores, siguiendo ese utilizamos a menudo:

Thread(Runnable threadOb,String threadName);

Aquí, threadOb es una instancia de una clase que implementa la interfaz Ejecutable, y threadName especifique el nuevo nombre de la rosca.

Una vez creado el nuevo hilo, se llama a su método start () se ejecutará.

void start();

Ejemplos

He aquí un ejemplo de ello para crear un hilo y comenzar la ejecución de:

// 创建一个新的线程
class NewThread implements Runnable {
   Thread t;
   NewThread() {
      // 创建第二个新线程
      t = new Thread(this, "Demo Thread");
      System.out.println("Child thread: " + t);
      t.start(); // 开始线程
   }
  
   // 第二个线程入口
   public void run() {
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
            // 暂停线程
            Thread.sleep(50);
         }
     } catch (InterruptedException e) {
         System.out.println("Child interrupted.");
     }
     System.out.println("Exiting child thread.");
   }
}
 
public class ThreadDemo {
   public static void main(String args[]) {
      new NewThread(); // 创建一个新线程
      try {
         for(int i = 5; i > 0; i--) {
           System.out.println("Main Thread: " + i);
           Thread.sleep(100);
         }
      } catch (InterruptedException e) {
         System.out.println("Main thread interrupted.");
      }
      System.out.println("Main thread exiting.");
   }
}

Compilar el programa anterior se ejecuta como sigue:

Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.

Para crear un hilo por hilo herencia

La segunda forma de crear un hilo es crear una nueva clase que hereda de la clase Thread, y luego crear una instancia de una clase.

La herencia de clase debe reemplazar el método run (), que es el punto de entrada para el nuevo hilo. También debe llamar al método start () para ejecutar.

Ejemplos

// 通过继承 Thread 创建线程
class NewThread extends Thread {
   NewThread() {
      // 创建第二个新线程
      super("Demo Thread");
      System.out.println("Child thread: " + this);
      start(); // 开始线程
   }
 
   // 第二个线程入口
   public void run() {
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
                            // 让线程休眠一会
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Child interrupted.");
      }
      System.out.println("Exiting child thread.");
   }
}
 
public class ExtendThread {
   public static void main(String args[]) {
      new NewThread(); // 创建一个新线程
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Main Thread: " + i);
            Thread.sleep(100);
         }
      } catch (InterruptedException e) {
         System.out.println("Main thread interrupted.");
      }
      System.out.println("Main thread exiting.");
   }
}

Compilar el programa anterior se ejecuta como sigue:

Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.

Métodos de hilo

La siguiente tabla muestra la clase Thread algunos aspectos importantes:

Comprueba si este hilo está activo. El método anterior se denomina objeto Thread. El siguiente método es un método estático de la clase Thread.

Ejemplos

El programa siguiente muestra algunas de las formas ThreadClassDemo clase Thread:

// 文件名 : DisplayMessage.java
// 通过实现 Runnable 接口创建线程
public class DisplayMessage implements Runnable
{
   private String message;
   public DisplayMessage(String message)
   {
      this.message = message;
   }
   public void run()
   {
      while(true)
      {
         System.out.println(message);
      }
   }
}

// 文件名 : GuessANumber.java
// 通过继承 Thread 类创建线程

public class GuessANumber extends Thread
{
   private int number;
   public GuessANumber(int number)
   {
      this.number = number;
   }
   public void run()
   {
      int counter = 0;
      int guess = 0;
      do
      {
          guess = (int) (Math.random() * 100 + 1);
          System.out.println(this.getName()
                       + " guesses " + guess);
          counter++;
      }while(guess != number);
      System.out.println("** Correct! " + this.getName()
                       + " in " + counter + " guesses.**");
   }
}

// 文件名 : ThreadClassDemo.java
public class ThreadClassDemo
{
   public static void main(String [] args)
   {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
     
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();
 
      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try
      {
         thread3.join();
      }catch(InterruptedException e)
      {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
     
           thread4.start();
      System.out.println("main() is ending...");
   }
}

Los resultados son como sigue, los resultados de cada ejecución no son los mismos.

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Thread-2 guesses 27
Hello
** Correct! Thread-2 in 102 guesses.**
Hello
Starting thread4...
Hello
Hello
..........remaining result produced.

Enhebrar varios conceptos importantes:

Cuando la programación multihilo, es necesario comprender los siguientes conceptos:

• sincronización hilo
• La comunicación entre hilos
• interbloqueo de subproceso
• control del hilo: Suspender, detener y reanudar

El uso de múltiples hilos

La clave para el uso eficaz de los programas multihilo son la ejecución simultánea se entiende en lugar de ejecución en serie. Por ejemplo: El programa tiene dos subsistemas necesitan para ejecutar al mismo tiempo, este tiempo que necesita para tomar ventaja de la programación multi-hilo.

A través del uso de múltiples hilos, se puede escribir un programa muy eficiente. Sin embargo, tenga en cuenta que si crea demasiadas hebras, la eficiencia de la ejecución del programa es realmente reducido, en lugar de mejorarse.

Recuerde, el interruptor de sobrecarga contexto también es muy importante, si se crea demasiadas hebras, el tiempo de CPU empleado en el contexto de tiempo de ejecución del programa de conmutación será más!