Methode zur Erstellung eines Java-Threads für die gleichzeitige Programmierung:

1. Threads und Prozesse

Ein Prozess ist eine laufende Codeaktivität für eine Datensammlung. Er ist die Grundeinheit der Ressourcenzuweisung und -planung im System. In einem Prozess gibt es mindestens einen Thread, der die Grundeinheit der CPU-Planung und -Zuweisung darstellt. Mehrere Threads im Prozess teilen sich die Ressourcen des Prozesses.

Drei Merkmale des Prozesses:

• Dynamik: Process It ist ein laufendes Programm, das dynamisch Ressourcen wie Speicher, CPU und Netzwerk belegt.

• Unabhängigkeit: Prozesse sind unabhängig voneinander und verfügen über eigene unabhängige Speicherbereiche.

• Parallelität: Wenn die CPU ein einzelner Kern ist, wird tatsächlich nur ein Prozess gleichzeitig im Speicher ausgeführt. Die CPU fragt nacheinander ab und schaltet nacheinander um, um jeden Prozess zu bedienen. Da die Umschaltgeschwindigkeit sehr hoch ist, haben wir das Gefühl, dass diese Prozesse gleichzeitig ausgeführt werden.

2. Erstellung und Ausführung von Threads

Es gibt drei Möglichkeiten, wie wir Threads in einem Prozess erstellen können: #🎜🎜 #

• Methode 1: Erben der Thread-Klasse

• 1. Definieren Sie eine Thread-Klasse, die die Thread-Klasse erbt.

• 2. Überschreiben Sie die run()-Methode

• 3.

• 4. Rufen Sie die start()-Methode des Thread-Objekts auf, um den Thread zu starten.

public class ThreadDemo {
    // 启动后的ThreadDemo当成一个进程。
    // main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args) {
        // 3.创建一个线程对象
        Thread t = new MyThread();
        // 4.调用线程对象的start()方法启动线程,最终还是执行run()方法！
        t.start();

        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("main线程输出："+i);
        }
    }
}

// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
    // 2.重写run()方法
    @Override
    public void run() {
        // 线程的执行方法。
        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("子线程输出："+i);
        }
    }
}

Vorteile: Einfach zu codieren, verwenden Sie dies einfach direkt, um den aktuellen Thread in der run()-Methode abzurufen, ohne Thread zu verwenden . currentThread()-Methode. Nachteile: Die Thread-Klasse hat die Thread-Klasse geerbt und kann keine anderen Klassen erben, und Funktionen können nicht durch Vererbung erweitert werden (Einschränkungen der Einzelvererbung). Darüber hinaus sind Aufgaben und Codes nicht getrennt. Wenn mehrere Threads dieselbe Aufgabe ausführen, sind mehrere Aufgabencodes erforderlich.

Zusammenfassung:

• Die Thread-Klasse ist eine Klasse, die Thread erbt.

• Die start()-Methode muss aufgerufen werden, um den Thread zu starten.

• Multithreading dient dazu, die CPU-Ausführung gleichzeitig zu verhindern, sodass während des Ausführungsprozesses Parallelitätszufälligkeit auftritt

#🎜🎜 #

Methode 2:

Die Art und Weise, die Runnable-Schnittstelle zu implementieren.

1 Erstellen Sie eine Thread-Task-Klasse, um die Runnable-Schnittstelle zu implementieren.
2. Überschreiben Sie die run()-Methode
3.
4. Packen Sie das Thread-Aufgabenobjekt in ein Thread-Objekt
5 Die Thread-Objekt-Methode startet den Thread.

• public class ThreadDemo {
      public static void main(String[] args) {
          // 3.创建一个线程任务对象(注意：线程任务对象不是线程对象，只是执行线程的任务的)
          Runnable target = new MyRunnable();
          // 4.把线程任务对象包装成线程对象.且可以指定线程名称
          // Thread t = new Thread(target);
          Thread t = new Thread(target,"1号线程");
          // 5.调用线程对象的start()方法启动线程
          t.start();
  
          Thread t2 = new Thread(target);
          // 调用线程对象的start()方法启动线程
          t2.start();
  
          for(int i = 0 ; i < 10 ; i++ ){
              System.out.println(Thread.currentThread().getName()+"==>"+i);
          }
      }
  }
  
  // 1.创建一个线程任务类实现Runnable接口。
  class MyRunnable implements Runnable{
      // 2.重写run()方法
      @Override
      public void run() {
          for(int i = 0 ; i < 10 ; i++ ){
              System.out.println(Thread.currentThread().getName()+"==>"+i);
          }
      }
  }

Vorteile:

Die Thread-Task-Klasse implementiert nur die Runnable-Schnittstelle und kann weiterhin andere erben Klassen Und Sie können weiterhin andere Schnittstellen implementieren (wodurch die Einschränkungen der Einzelvererbung vermieden werden). Dasselbe Thread-Aufgabenobjekt kann in mehrere Thread-Objekte gepackt werden, sodass mehrere Threads dieselbe Ressource gemeinsam nutzen können. Um Entkopplungsvorgänge zu erreichen, kann der Thread-Task-Code von mehreren Threads gemeinsam genutzt werden, und Thread-Task-Code und Threads sind unabhängig.

Methode drei:

Implementieren Sie die Callable-Schnittstelle

1. Definieren Sie eine Thread-Task-Klasse, um Callable zu implementieren Schnittstelle, deklarieren Sie den Ergebnistyp der Thread-Ausführung.
2. Schreiben Sie die Aufrufmethode der Thread-Task-Klasse neu. Diese Methode kann das Ausführungsergebnis direkt zurückgeben.
3 Erstellen Sie ein aufrufbares Thread-Aufgabenobjekt.
4. Packen Sie das Callable-Thread-Aufgabenobjekt in ein FutureTask-Objekt.
5. Packen Sie das FutureTask-Objekt in ein Thread-Objekt.
6 Rufen Sie die start()-Methode des Threads auf, um den Thread zu starten.

• public class ThreadDemo {
      public static void main(String[] args) {
          // 3.创建一个Callable的线程任务对象
          Callable call = new MyCallable();
          // 4.把Callable任务对象包装成一个未来任务对象
          //      -- public FutureTask(Callable<V> callable)
          // 未来任务对象是啥，有啥用？
          //      -- 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！
          //      -- 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。
          FutureTask<String> task = new FutureTask<>(call);
          // 5.把未来任务对象包装成线程对象
          Thread t = new Thread(task);
          // 6.启动线程对象
          t.start();
  
          for(int i = 1 ; i <= 10 ; i++ ){
              System.out.println(Thread.currentThread().getName()+" => " + i);
          }
  
          // 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
          try {
              String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
              System.out.println(rs);
          }  catch (Exception e) {
              e.printStackTrace();
          }
  
      }
  }
  
  // 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型
  class MyCallable implements Callable<String>{
      // 2.重写线程任务类的call方法！
      @Override
      public String call() throws Exception {
          // 需求：计算1-10的和返回
          int sum = 0 ;
          for(int i = 1 ; i <= 10 ; i++ ){
              System.out.println(Thread.currentThread().getName()+" => " + i);
              sum+=i;
          }
          return Thread.currentThread().getName()+"执行的结果是："+sum;
      }
  }

Vorteile:

Die Thread-Task-Klasse implementiert nur die Callable-Schnittstelle, kann weiterhin andere Klassen erben und kann weiterhin andere implementieren Schnittstellen (vermeiden Sie (außerhalb der Einschränkungen der Einzelvererbung). Dasselbe Thread-Aufgabenobjekt kann in mehrere Thread-Objekte gepackt werden, sodass mehrere Threads dieselbe Ressource gemeinsam nutzen können. Um Entkopplungsvorgänge zu erreichen, kann der Thread-Task-Code von mehreren Threads gemeinsam genutzt werden, und Thread-Task-Code und Threads sind unabhängig. Das Wichtigste ist, die Ergebnisse der Thread-Ausführung direkt abrufen zu können.

Das obige ist der detaillierte Inhalt vonMethode zur Erstellung eines Java-Threads für die gleichzeitige Programmierung:. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!