Detailed explanation of Java multi-threading implementation

Java multi-threading enables concurrent programming and improves performance and responsiveness. Threads can be created by inheriting the Thread class or implementing the Runnable interface. The thread life cycle includes NEW, RUNNABLE and other states. Synchronization mechanisms such as mutex locks and the synchronized keyword avoid data races. The actual case shows the scenario of multi-threaded file downloading. Parallel downloading is achieved by creating a thread pool and download tasks.

Detailed explanation of Java multi-threading

Introduction

Multi-threading is implemented in Java The basic mechanism of concurrent programming that allows applications to perform multiple tasks simultaneously to improve performance and responsiveness. This article will introduce in detail the concept, implementation and practical cases of Java multithreading.

Thread Basics

A thread is a lightweight process that shares memory and resources with other threads. In Java, threads are represented using the Thread class, which provides methods to start, pause, and stop threads.

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

Creating threads

Threads can be created in two ways:

• Inherit the Thread class : You can create a new class that extends the Thread class and override the run() method to specify the tasks performed by the thread.
• Implements the Runnable interface: It is possible to create a new class that implements the Runnable interface, which is just a class with run() Method interface. This class can then be passed as a parameter to the Thread constructor.

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

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

Thread life cycle

A thread can be in one of the following states:

• NEW: The thread has been created but not started yet.
• RUNNABLE: The thread is running.
• BLOCKED: The thread is waiting for a resource.
• WAITING: The thread is waiting for a certain condition.
• TIMED_WAITING: The thread is waiting for a certain condition, up to the specified time.
• TERMINATED: The thread has completed execution.

Thread synchronization

When multiple threads access shared resources, they must be synchronized to avoid data races. Java provides the following synchronization mechanism:

• Mutex lock:Each object has its own built-in mutex lock, which can be used to ensure that only one thread accesses the object at a time Share data.
• synchronized keyword: The synchronized keyword can be added to a method or block of code to ensure that only the thread holding the object's lock can execute the code.

Practical case: Multi-threaded file download

The following code demonstrates how to use multi-threading to download files from multiple URLs:

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

The above is the detailed content of Detailed explanation of Java multi-threading implementation. For more information, please follow other related articles on the PHP Chinese website!