Java programação multi-threaded

Java programação multi-threaded para fornecer suporte embutido. Um programa multithread contém duas ou mais porções podem ser executadas simultaneamente. Cada parte do programa é chamado de linha, e cada fio define um percurso de execução separado.

Multithreading é uma forma especial de multi-tasking, multi-threading, mas usar um excesso de recursos menor.

Outro termo é aqui definido, e linha relacionada com a - processo: um processo incluindo o sistema operativo aloca o espaço de memória que contém um ou mais segmentos. Um segmento separado não pode existir, ele deve ser parte do processo. Um processo foi executado ao fim de toda a não-espera até que após o final do segmento a ser executado.

Multithreading pode atender aos programadores escrever programa eficiente para atingir fins de utilização de CPU completos.

ciclo de vida de um fio

Linha através todas as fases do seu ciclo de vida. A figura a seguir mostra o ciclo de vida completo de um segmento.

• Novo Estado:

  Depois de utilizar a nova palavra-chave e da classe Thread ou subclasse para criar um objeto de discussão, o objeto de segmento está em um novo estado. Ele permanece nesse estado até o início do programa () esta discussão.

• estado de pronto:

  Quando um objeto de segmento para chamar o método start (), o segmento para o estado preparado. rosca pronta na fila de pronto, para aguardar o programador agendamento de segmento JVM.

• Estado de funcionamento:

  Se o segmento recebe estado de prontidão dos recursos da CPU, você pode executar run (), o segmento será executado neste momento. Segmento em execução o mais complexo, ele pode se tornar estado bloqueado, estado de pronto, eo estado de morte.

• estado bloqueado:

  Se um segmento é executado após o sono (sono), suspender (não reagir) e outros métodos, a perda de recursos ocupados, o fio entra no estado bloqueado de execução. Após o tempo de sono tem vindo a obter equipamentos ou recursos para re-entrar no estado de pronto.

• Death Estado:

  Quando um segmento estado da tarefa ou outra condição de término em execução ocorre, o segmento é comutada para o estado final.

prioridade de um segmento

Cada encadeamento Java tem uma prioridade, o que ajuda a determinar o sistema operacional a fim de escalonamento de threads.

A prioridade de thread Java é um número inteiro que varia de 1 (Thread.MIN_PRIORITY) - 10 (Thread.MAX_PRIORITY).

Por padrão, cada thread é atribuído um NORM_PRIORITY prioridade (5).

Linha com uma prioridade mais alta é mais importante para o programa, e deve alocar recursos do processador antes de baixos tópicos prioritários. No entanto, a ordem não garante rosca prioridade de execução, e é muito dependente da internet.

Criar um fio

Java fornece dois métodos para criar um fio:

• Runable implementando a interface;
• Através da própria herança de classe Thread.

Para criar uma lista de discussão através da implementação de interface Runnable

Criar um fio, a maneira mais fácil é criar uma classe que implementa a interface Runnable.

A fim de alcançar Runnable, uma classe só precisa realizar uma corrida chamada de método (), a seguinte declaração:

public void run()

Você pode substituir esse método, é importante compreender o run () pode chamar outros métodos, o uso de outras classes, e declarar uma variável, assim como o segmento principal.

Depois de criar uma classe implementa a interface Runnable, você pode instanciar um objeto na classe um fio.

Tópico define vários construtores, estão seguindo este muitas vezes usamos:

Thread(Runnable threadOb,String threadName);

Aqui, threadOb é uma instância de uma classe que implementa a interface Runnable, e threadName especificar o novo nome da rosca.

Depois que o novo segmento é criado, você chamar o método start () ele será executado.

void start();

Exemplos

Aqui está um exemplo de que para criar uma linha e iniciar a execução 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 o programa acima é a seguinte:

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 criar uma linha através da linha de herança

A segunda maneira de criar uma lista de discussão é a criação de uma nova classe que herda a classe Thread, e, em seguida, criar uma instância de uma classe.

classe herdando deve substituir o método run (), que é o ponto de entrada para o novo segmento. Ele também deve chamar o método start () para executar.

Exemplos

// 通过继承 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 o programa acima é a seguinte:

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 rosca

A tabela a seguir lista a classe Thread alguns aspectos importantes:

Testa se esta discussão está ativa. O método acima é chamado objecto rosca. O método que se segue é um método estático da classe Thread.

Exemplos

O programa a seguir demonstra algumas das maneiras 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...");
   }
}

Os resultados são como se segue, os resultados de cada ensaio não são os mesmos.

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.

Passe vários conceitos principais:

Quando vários segmentos programação, você precisa entender os seguintes conceitos:

• Sincronização Tópico
• A comunicação entre os tópicos
• impasse rosca
• controle Tópico: Suspender, pare e currículo

Usar vários segmentos

A chave para a utilização eficaz dos programas multi-threaded estão execução concorrente é entendida ao invés de execução serial. Por exemplo: O programa tem dois subsistemas precisa executar simultaneamente, desta vez você precisa tirar proveito de programação multi-threaded.

Através da utilização de vários segmentos, você pode escrever um programa muito eficiente. No entanto, note que se você criar muitos segmentos, a eficiência da execução do programa é realmente reduzida, ao invés de melhorado.

Lembre-se, o interruptor de sobrecarga de contexto também é muito importante, se você criar muitos segmentos, o tempo de CPU gasto no contexto de tempo de execução do programa de comutação será mais!