Java programmazione multi-threaded

Java programmazione multi-threaded per fornire il supporto built-in. Un programma multithreaded contiene due o più porzioni possono essere eseguiti contemporaneamente. Ogni parte del programma è chiamato un filo, e ogni thread definisce un percorso separato di esecuzione.

Il multithreading è una forma speciale di multi-tasking, multi-threading, ma utilizzare un overhead risorsa più piccolo.

Un altro termine viene definito nel presente documento, e filo-correlato - processo: un processo compreso il sistema operativo alloca lo spazio di memoria che contiene uno o più thread. Un thread separato non può esistere, deve essere parte del processo. Un processo è stato eseguito al fine di tutti i non-attesa fino a dopo la fine del filo da eseguire.

Multithreading in grado di soddisfare i programmatori di scrivere il programma efficiente per raggiungere scopi pieno utilizzo della CPU.

ciclo di vita di un filo

Filetto attraverso tutte le fasi del suo ciclo di vita. La figura seguente mostra il ciclo di vita completo di un thread.

• Nuovo stato:

  Dopo aver utilizzato la nuova parola chiave e la classe Thread o sottoclasse per creare un oggetto filo, l'oggetto thread è in un nuovo stato. Esso rimane in questo stato fino all'inizio del programma () questo thread.

• stato Pronto:

  Quando un oggetto thread per chiamare il metodo start (), il filo nello stato pronto. filetto pronto in coda pronto ad attendere la programmazione scheduler filo JVM.

• Stato di funzionamento:

  Se il filo si stato pronto di risorse della CPU, è possibile eseguire run (), il filo sarà in esecuzione in questo momento. Filo conduttore il più complesso, può diventare stato bloccato, lo stato pronto, e lo stato di morte.

• stato di blocco:

  Se un thread viene eseguito dopo il sonno (sonno), la sospensione (blocco) e altri metodi, la perdita di risorse occupate, il filo entra nello stato bloccato in esecuzione. Dopo che è giunto il tempo di sonno per ottenere attrezzature o risorse di ri-entrare nello stato pronto.

• La morte di stato:

  Quando si verifica un thread stato dell'attività o di altra condizione di terminazione esecuzione, il filo viene commutato allo stato finale.

la priorità di un filo

Ogni thread Java ha una priorità, che consente di determinare il sistema operativo ordine programmazione dei thread.

la priorità del thread Java è un numero intero che va da 1 (Thread.MIN_PRIORITY) - 10 (Thread.MAX_PRIORITY).

Per impostazione predefinita, ogni thread viene assegnata una priorità NORM_PRIORITY (5).

Discussione con una priorità più alta è più importante per il programma, e dovrebbe allocare le risorse del processore prima di discussioni a bassa priorità. Tuttavia, l'ordine non garantisce filo filo priorità di esecuzione, ed è molto dipendente da internet.

Creare un filo

Java fornisce due metodi per creare un filo:

• Runable implementando l'interfaccia;
• Attraverso l'eredità classe Thread stessa.

Per creare un thread implementando l'interfaccia Runnable

Creare un thread, il modo più semplice è quello di creare una classe che implementa l'interfaccia Runnable.

Al fine di raggiungere Runnable, una classe deve effettuare solo una corsa chiamata al metodo (), la seguente dichiarazione:

public void run()

È possibile ignorare questo metodo, è importante capire il run () può chiamare altri metodi, l'uso di altre classi, e dichiarare una variabile, proprio come il filo conduttore.

Dopo aver creato una classe implementa l'interfaccia Runnable, è possibile creare un'istanza di un oggetto nella classe un filo.

Discussione definisce diversi costruttori che stanno seguendo questo usiamo spesso:

Thread(Runnable threadOb,String threadName);

Qui, threadOb è un'istanza di una classe che implementa l'interfaccia Runnable, e ThreadName specificare il nuovo nome del thread.

Dopo aver creato il nuovo thread, si chiama il metodo start () verrà eseguito.

void start();

Esempi

Ecco un esempio di esso per creare un filo e iniziare l'esecuzione di:

// 创建一个新的线程
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.");
   }
}

Compilare il programma di cui sopra è la seguente:

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.

Per creare un filo attraverso l'ereditarietà

Il secondo modo per creare un thread è quello di creare una nuova classe che eredita la classe Thread, e quindi creare un'istanza di una classe.

classe che eredita deve sovrascrivere il metodo run (), che è il punto di ingresso per il nuovo thread. Deve inoltre chiamare il metodo start () per eseguire.

Esempi

// 通过继承 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.");
   }
}

Compilare il programma di cui sopra è la seguente:

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.

Metodi discussione

La seguente tabella elenca classe Thread alcuni modi importanti:

Prove se questa discussione è attiva. Il metodo di cui sopra si chiama oggetto Thread. Il seguente metodo è un metodo statico della classe Thread.

Esempi

Il seguente programma illustra alcuni dei modi ThreadClassDemo classe 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...");
   }
}

I risultati sono i seguenti, i risultati di ogni esecuzione non sono gli stessi.

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.

Far passare alcuni importanti concetti:

Quando multithread di programmazione, è necessario comprendere i seguenti concetti:

• sincronizzazione dei thread
• La comunicazione tra i thread
• stallo Discussione
• Controllo Discussione: Sospendere, interrompere e riprendere

Utilizzare più thread

La chiave per un uso efficace dei programmi multi-threaded sono esecuzione concorrente Resta inteso, piuttosto che l'esecuzione di serie. Per esempio: Il programma ha due sottosistemi hanno bisogno di eseguire contemporaneamente, questa volta è necessario approfittare di programmazione multi-threaded.

Attraverso l'uso di più thread, è possibile scrivere un programma molto efficiente. Tuttavia, si ricorda che se si crea troppi thread, l'efficienza di esecuzione del programma è effettivamente ridotto, piuttosto che migliorata.

Ricordate, il cambio di contesto overhead è anche molto importante, se si crea troppi thread, il tempo di CPU speso in un contesto di tempo di esecuzione del programma di commutazione sarà più!