Detaillierte Erläuterung von Java-Threads und des Unterschieds zwischen Threads und Prozessen

Detaillierte Erklärung von Java-Threads und dem Unterschied zwischen Threads und Prozessen

1. Prozesse und Threads

Jeder Prozess verfügt über seinen eigenen Speicherplatz und eine Anwendung kann mehrere Prozesse gleichzeitig starten Zeit. Beim IE-Browser entspricht das Öffnen eines IE-Browsers beispielsweise dem Starten eines Prozesses.

Thread bezieht sich auf einen Ausführungsprozess in einem Prozess. Ein Prozess kann mehrere Threads enthalten.

Für jeden Prozess muss das Betriebssystem unabhängigen Speicherplatz zuweisen, und mehrere Threads im selben Prozess teilen sich diesen Speicherplatz, d. h. gemeinsam genutzten Speicher und andere Ressourcen.

Jedes Mal, wenn java.exe aufgerufen wird, startet das Betriebssystem einen Java Virtual Machine-Prozess. Wenn der Java Virtual Machine-Prozess gestartet wird, erstellt die Java Virtual Machine einen Hauptthread, der vom Programm aus gestartet wird Eintrag Hauptmethode. Starten Sie die Ausführung.

Jedes Mal, wenn eine Java Virtual Machine einen Thread startet, weist sie dem Thread einen Thread-Methodenstapel zu, um relevante Informationen (z. B. lokale Variablen usw.) zu speichern, und der Thread wird auf diesem Stapel ausgeführt. Daher sind lokale Variablen in Java-Objekten threadsicher, Instanzvariablen und Klassenvariablen jedoch nicht threadsicher, da sie nicht auf dem Stapel gespeichert werden.

Der Prozess hat drei Zustände: bereit, ausgeführt und blockiert.

2. Thread-Erstellungsmethode

Ausführbare Methode: (Diese Methode ist flexibel und wird empfohlen)

public class Thread02 implements Runnable {
  
  public static void main(String[] args) {
    Runnable r = new <strong>Thread02</strong>();
    Thread t1 = new Thread(<strong>r</strong>, "t1");
    /**
     *   Thread源码
     *   public Thread(Runnable target, String name) {
          init(null, target, name, 0);
             }
     */
    Thread t2 = new Thread(r, "t2");
    t1.start(); // 启动线程t1，处于就绪状态，等待cpu
    t2.start(); // 启动线程t2，处于就绪状态，等待cpu
    t1.run(); // 主线程main调用对象t1的run方法
  }
  
  public void run() {
    System.out.println("thread&#39;s name is "
        + Thread.currentThread().getName());
  }
  
}

Das laufende Ergebnis kann sein:

thread's name is t1
thread's name is main
thread's name is t2

Thead-Methode

public class Thread03 extends Thread {
  
  public static void main(String[] args) {
    Thread03 t1 = new <strong>Thread03</strong>();   //不注意的情况下写成了Thread t1=new Thread()  注：Thread03此时就是一个线程了
    t1.start();
  }
  
  public void run() {
    System.out.println("thread&#39;s name is "
        + Thread.currentThread().getName());
  }
}

Das laufende Ergebnis: Der Name des Threads ist Thread-0

Hinweis: Jedes Mal, wenn das Programm ausgeführt wird, gibt es zusätzlich zum benutzerdefinierten Thread einen Hauptthread.

Allgemeines:

public class Thread01 {
  public static void main(String[] args) {
 
    Thread thread=new Thread();
    thread.start();//真正起作用 的是run()
    /**而Thread中的run
     * public void run() {
      if (target != null) {
        target.run();
      }
      }
      所以自己创建的线程要重写run方法，把要执行的内容放到run()中，所以要实现接口或继承进而产生子类
     */
     
    //创建线程的方式1 thread子类方式（继承）
    Thread thread1=new Thread(){
      public void run() {
        while(true){
          try {
            Thread.sleep(500);//休息500毫秒
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          //Thread.currentThread()得到当前线程
          System.out.println("线程1的名字是 "+Thread.currentThread().getName());
        }
      }
    };
//    thread1.start(); //不写  线程无法启动
     
     
    //创建线程的方式2 runnable方式（实现） 推荐使用
    Thread thread2=new Thread(new Runnable(){
 
      public void run() {
 
        while(true){
          try {
            Thread.sleep(300);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println("thread2'name is "+Thread.currentThread().getName());
           
        }
      }});
//    thread2.start();
     
    //执行的是thread
    new Thread(new Runnable(){
      public void run() {
        System.out.println("runnable "+Thread.currentThread().getName());
      }}){
      public void run() { //子类中的run方法覆盖父类中的run方法，这样就不会执行runnable
        System.out.println("thread "+Thread.currentThread().getName());
      }
    }.start();
  }
  /***
   * 在单个cpu中执行多线程很有可能降低执行效率而不是提高 一个人在不同地方做同一件事情
   */
}

Vielen Dank fürs Lesen, ich hoffe, es kann allen helfen, vielen Dank für Ihre Unterstützung dieser Website!

Ausführlichere Erläuterungen zu Java-Threads und den Unterschieden zwischen Threads und Prozessen finden Sie auf der chinesischen PHP-Website!