Programowanie wielowątkowych Java

Programowanie wielowątkowych Java, aby zapewnić wbudowaną obsługę. Wielowątkowy program zawiera dwie lub więcej części mogą działać jednocześnie. Każda część programu nosi nazwę wątku, a każdy wątek definiuje osobną ścieżkę realizacji.

Wielowątkowość jest specjalną formą wielozadaniowych, wielowątkowości, ale użyć mniejszego obciążenie zasobów.

Inną definicją w niniejszym opisie, i nici związane - proces: Proces tym system operacyjny przydziela obszar pamięci, który zawiera jeden lub większą liczbę wątków. Odrębny wątek nie może istnieć, to musi być częścią procesu. Proces prowadzi się do zakończenia wszystkich nie-czekania do czasu, gdy koniec nitki uruchomić.

Wielowątkowość może spełnić programistów napisać skuteczny program do osiągnięcia pełnego cele wykorzystanie procesora.

Cykl życia nitki za

Wątek na wszystkich etapach cyklu życia produktu. Poniższy rysunek przedstawia kompletny cykl życia wątku.

• Nowy status:

  Po użyciu nowego słowa kluczowego i klasy lub podklasy wątku utworzyć obiekt nici, obiekt wątek jest w nowym stanie. To pozostaje w tym stanie aż do początku programu () tego wątku.

• Stan Ready:

  Kiedy obiekt wątku wywołać metodę start (), wątek w stan gotowości. Gwint gotowa w kolejce gotowości czekać na wątków JVM harmonogramu planowania.

• Stan pracy:

  Jeśli wątek jest gotowy stan zasobów procesora, można wykonać run (), wątek zostanie uruchomiony w tym czasie. Nić najbardziej skomplikowany, może stać zablokowana stan, stan gotowości, a stan śmierci.

• Zablokowane Stan:

  Jeśli wątek jest wykonywany po uśpienia (Sleep), zawieszenia (zawiesić się) i innych metod, utrata zajmowanych zasobów, nitka przechodzi w stan zablokowany z systemem. Po upływie tego czasu snu nadszedł dostać urządzeń lub zasobów, aby ponownie wprowadzić stan gotowy.

• Śmierć Status:

  Gdy wystąpi nić stanu zadania lub inny warunek zakończenia, nić jest przełączany do stanu końcowego.

Priorytet wątku jest

Każdy wątek Java ma priorytet, który pomaga określić system operacyjny kolejność planowania wątków.

Priorytet wątku Java jest liczbą całkowitą, która waha się od 1 (Thread.MIN_PRIORITY) - 10 (Thread.MAX_PRIORITY).

Domyślnie każdy wątek jest przypisany NORM_PRIORITY priorytetu (5).

Temat z wyższym priorytetem jest ważniejsze do programu i powinny przydzielać zasoby procesora przed niskimi wątków priorytetowych. Jednak kolejność nie gwarantuje wątku priorytet wątku wykonania i jest bardzo uzależniony od internetu.

Tworzenie wątku

Java oferuje dwie metody utworzyć wątku:

• Runable poprzez wdrożenie interfejsu;
• Poprzez dziedziczenie samej klasy wątku.

Aby utworzyć wątku poprzez wdrożenie interfejsu Runnable

Tworzenie wątku, najprostszym sposobem jest utworzenie klasy, która implementuje Runnable interfejs.

W celu osiągnięcia Runnable, klasa musi wykonywać tylko bieganie metoda call (), następujące oświadczenie:

public void run()

Można zastąpić tę metodę, ważne jest, aby zrozumieć run () może wywoływać inne metody, korzystanie z innych klas, a zadeklarować zmienną, tak jak w głównym wątku.

Po utworzeniu klasy implementuje Runnable interfejs, można utworzyć wystąpienia obiektu w klasie wątek.

Temat definiuje kilka konstruktorów naśladują tego często używamy:

Thread(Runnable threadOb,String threadName);

Tutaj threadOb jest instancją klasy, która implementuje Runnable interfejs i threadName określa nową nazwę wątku.

Po utworzeniu nowego wątku, to metoda będzie działać jego start () zadzwonić.

void start();

Przykłady

Tutaj jest przykładem tego, aby utworzyć wątku i rozpocząć realizację:

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

Skompilować powyższy program działa w następujący sposób:

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.

Aby utworzyć wątku w drodze dziedziczenia wątek

Drugi sposób, aby utworzyć wątku jest stworzenie nowej klasy, która dziedziczy klasę wątku, a następnie utworzyć instancję klasy.

Dziedziczenie klasy musi zastąpić metodę run (), która jest punktem wyjścia dla nowego wątku. Należy również wywołać metodę start (), aby wykonać.

Przykłady

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

Skompilować powyższy program działa w następujący sposób:

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.

Metody wątku

Poniższa tabela zawiera klasę wątku kilka ważnych sposobów:

Testy jeśli ten wątek jest aktywny. Powyższa metoda jest wywoływana obiektu wątku. Poniższa metoda jest metodą statyczną klasy Thread.

Przykłady

Poniższy program pokazuje tylko niektóre ze sposobów ThreadClassDemo klasy wątku:

// 文件名 : 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...");
   }
}

Wyniki są następujące wyniki każdego silnika nie są takie same.

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.

Wątek kilka ważnych pojęć:

Gdy programowanie wielowątkowe, trzeba zrozumieć następujące pojęcia:

• Synchronizacja wątek
• Komunikacja między wątkami
• impas wątek
• Kontrola Temat: Zawieszenie, zatrzymać i wznowić

Korzystanie z wielu wątków

Kluczem do efektywnego wykorzystania programów wielowątkowych są współbieżne wykonanie jest zrozumiałe niż wykonanie szeregowej. Na przykład: Program posiada dwa podsystemy muszą wykonywać jednocześnie, tym razem trzeba skorzystać z programowaniem wielowątkowym.

Dzięki zastosowaniu wielu wątków, można napisać bardzo skuteczny program. Należy jednak pamiętać, że jeśli tworzysz zbyt wiele tematów, sprawność wykonywania programu jest rzeczywiście obniżona, a nie wzmocnione.

Pamiętaj, przełącznik napowietrznych kontekst jest również bardzo ważne, jeśli tworzysz zbyt wiele tematów, czas CPU spędzony w kontekście czasu realizacji programu przełączania będzie więcej!