Penjelasan terperinci tentang pelaksanaan multi-threading Java

Java multi-threading membolehkan pengaturcaraan serentak, meningkatkan prestasi dan responsif. Thread boleh dibuat dengan mewarisi kelas Thread atau melaksanakan antara muka Runnable. Kitaran hayat benang termasuk keadaan BARU, BOLEH LALU dan lain-lain. Mekanisme penyegerakan seperti kunci mutex dan kata kunci yang disegerakkan mengelakkan perlumbaan data. Kes sebenar menunjukkan senario muat turun fail berbilang benang, muat turun selari dicapai dengan mencipta kumpulan benang dan tugasan muat turun.

Penjelasan terperinci tentang Java multi-threading

Pengenalan

Multi-threading ialah mekanisme asas untuk melaksanakan pengaturcaraan serentak dalam Java responsif. Artikel ini akan memperkenalkan secara terperinci konsep, pelaksanaan dan kes-kes praktikal bagi multithreading Java.

Asas Benang

Benang ialah proses ringan yang berkongsi memori dan sumber dengan utas lain. Di Java, utas diwakili menggunakan kelas Thread, yang menyediakan kaedah untuk memulakan, menjeda dan menghentikan utas. Thread 类表示，它提供了启动、暂停和停止线程的方法。

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的任务
    }
}

创建线程

可以以两种方式创建线程：

• 继承 Thread 类：可以创建一个扩展 Thread 类的新类，并重写 run() 方法来指定线程执行的任务。
• 实现 Runnable 接口：可以创建实现 Runnable 接口的新类，它只是一个具有 run() 方法的接口。然后，可以将该类作为参数传递给 Thread 构造函数。

// 继承 Thread 类
class MyThread extends Thread {
    public void run() {
        // 线程执行的任务
    }
}

// 实现 Runnable 接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的任务
    }
}

线程生命周期

一个线程可以处于以下状态之一：

• NEW：线程已被创建，但尚未启动。
• RUNNABLE：线程正在运行。
• BLOCKED：线程正在等待资源。
• WAITING：线程正在等待某个条件。
• TIMED_WAITING：线程正在等待某个条件，最多等待指定的时间。
• TERMINATED：线程已完成执行。

线程同步

当多个线程访问共享资源时，必须同步它们以避免数据竞争。Java 提供了以下同步机制：

• 互斥锁：每个对象都有自己的内置互斥锁，可以用来确保一次只有一个线程访问该对象的共享数据。
• synchronized 关键字：可以将 synchronized

  import java.net.URL;
  import java.net.URLConnection;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  
  public class MultiThreadedDownloader {
  
      public static void main(String[] args) {
          String[] urls = {
              "https://example.com/file1.zip",
              "https://example.com/file2.zip",
              "https://example.com/file3.zip"
          };
  
          // 创建一个线程池
          ExecutorService executor = Executors.newFixedThreadPool(3);
  
          // 为每个 URL 创建一个下载任务
          for (String url : urls) {
              executor.submit(new DownloadTask(url));
          }
  
          // 关闭线程池
          executor.shutdown();
      }
  
      static class DownloadTask implements Runnable {
  
          private String url;
  
          public DownloadTask(String url) {
              this.url = url;
          }
  
          @Override
          public void run() {
              try {
                  // 从 URL 建立连接
                  URLConnection connection = new URL(url).openConnection();
  
                  // 设置下载位置
                  String fileName = url.substring(url.lastIndexOf('/') + 1);
                  File file = new File("downloads/" + fileName);
  
                  // 创建输出流
                  FileOutputStream outputStream = new FileOutputStream(file);
  
                  // 读取输入流并写入输出流
                  int read;
                  while ((read = connection.getInputStream().read()) != -1) {
                      outputStream.write(read);
                  }
  
                  // 关闭流
                  outputStream.close();
                  connection.getInputStream().close();
  
                  System.out.println("下载文件 " + fileName + " 完成");
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
  }

Buat Benang

Benang boleh dibuat dalam dua cara:

• Warisi kelas Benang:

  Anda boleh membuat sambungan Benang kelas Kelas baharu dan ganti kaedah run() untuk menentukan tugasan yang perlu dilakukan oleh utas. 🎜
• 🎜Laksanakan antara muka Runnable: 🎜Anda boleh mencipta kelas baharu yang melaksanakan antara muka Runnable, iaitu antara muka dengan run() kaedah . Kelas ini kemudiannya boleh dihantar sebagai parameter kepada pembina Thread. . 🎜
• 🎜BOLEH LARI: 🎜Benang sedang berjalan. 🎜
• 🎜DISEKAT: 🎜Benang sedang menunggu sumber. 🎜
• 🎜MENUNGGU: 🎜Benang sedang menunggu syarat tertentu. 🎜
• 🎜MASA_MENUNGGU: 🎜Benang sedang menunggu syarat tertentu, sehingga masa yang ditetapkan. 🎜
• 🎜DITAMATKAN: 🎜Urut telah selesai dilaksanakan. 🎜🎜🎜🎜Penyegerakan Benang🎜🎜🎜Apabila berbilang rangkaian mengakses sumber kongsi, ia mesti disegerakkan untuk mengelakkan perlumbaan data. Java menyediakan mekanisme penyegerakan berikut: 🎜
  • 🎜Kunci mutex: 🎜Setiap objek mempunyai kunci mutex terbina dalam sendiri, yang boleh digunakan untuk memastikan hanya satu utas mengakses data kongsi objek pada satu masa. 🎜
  • 🎜kata kunci disegerakkan: 🎜Kata kunci disegerakkan boleh ditambah pada kaedah atau blok kod untuk memastikan hanya benang yang memegang kunci objek boleh melaksanakan kod. 🎜🎜🎜🎜Kes praktikal: Muat turun fail berbilang benang🎜🎜🎜Kod berikut menunjukkan cara menggunakan berbilang benang untuk memuat turun fail daripada berbilang URL:🎜rrreee

Atas ialah kandungan terperinci Penjelasan terperinci tentang pelaksanaan multi-threading Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!