Explication détaillée des threads Java et de la différence entre les threads et les processus

Explication détaillée des threads Java et de la différence entre les threads et les processus

1. Processus et threads

Chaque processus a son propre espace mémoire et une application peut démarrer plusieurs processus en même temps. temps. Par exemple, avec le navigateur IE, ouvrir un navigateur IE équivaut à démarrer un processus.

Thread fait référence à un processus d'exécution dans un processus. Un processus peut contenir plusieurs threads.

Chaque processus nécessite que le système d'exploitation lui alloue un espace mémoire indépendant, et plusieurs threads dans le même processus partagent cet espace, c'est-à-dire la mémoire partagée et d'autres ressources.

Chaque fois que java.exe est appelé, le système d'exploitation démarre un processus de machine virtuelle Java. Lorsque le processus de machine virtuelle Java est démarré, la machine virtuelle Java crée un thread principal, qui démarre à partir du programme. méthode principale d'entrée. Démarrer l'exécution.

Chaque fois qu'une machine virtuelle Java démarre un thread, elle allouera une pile de méthodes de thread au thread pour stocker les informations pertinentes (telles que les variables locales, etc.), et le thread s'exécutera sur cette pile. Par conséquent, les variables locales dans les objets Java sont thread-safe, mais les variables d'instance et les variables de classe ne le sont pas car elles ne sont pas enregistrées sur la pile.

Le processus a trois états : prêt, en cours d'exécution et bloqué.

2. Méthode de création de fil de discussion

Méthode exécutable : (Cette méthode est flexible et recommandée)

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());
  }
  
}

Le résultat en cours d'exécution peut être :

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

Méthode Thead

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());
  }
}

Le résultat en cours d'exécution : le nom du fil est Thread-0

Remarque : chaque fois que le programme s'exécute, il existe un fil principal en plus du fil personnalisé.

Général :

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中执行多线程很有可能降低执行效率而不是提高 一个人在不同地方做同一件事情
   */
}

Merci d'avoir lu, j'espère que cela pourra aider tout le monde, merci pour votre soutien à ce site !

Pour des explications plus détaillées sur les threads Java et les différences entre les threads et les processus, veuillez faire attention au site Web PHP chinois !