Java 多线程编程：从入门到实践-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43393995/article/details/145966470

前言

多线程编程是 Java 开发中的重要技术之一，能够有效提升程序的并发性能。然而，多线程编程也伴随着复杂性，如线程安全、死锁等问题。本文将带你全面了解 Java 多线程编程的核心概念，并通过实际案例帮助你掌握多线程开发的技巧。

1. 多线程的基本概念

多线程是指在一个进程中同时运行多个线程，每个线程可以独立执行任务。多线程的优势在于：

提高 CPU 利用率。
提升程序的响应速度。
充分利用多核 CPU 的性能。

2. 创建线程的三种方式

2.1 继承 `Thread` 类

java

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程运行中: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

2.2 实现 `Runnable` 接口

java

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程运行中: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

2.3 使用 `Callable` 和 `Future`

java

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "线程返回值: " + Thread.currentThread().getName();
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> task = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(task);
        thread.start();
        System.out.println(task.get());
    }
}

3. 线程的生命周期

线程的生命周期包括以下状态：

新建（New）：线程被创建但尚未启动。
就绪（Runnable）：线程已启动，等待 CPU 调度。
运行（Running）：线程正在执行任务。
阻塞（Blocked）：线程等待资源（如锁）。
终止（Terminated）：线程执行完毕或异常终止。

4. 线程同步与锁机制

多线程环境下，共享资源的访问可能导致数据不一致问题。Java 提供了多种同步机制：

4.1 `synchronized` 关键字

java

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

4.2 `ReentrantLock`

java

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

5. 线程池的使用

线程池可以有效管理线程资源，避免频繁创建和销毁线程。Java 提供了 ExecutorService 框架：

java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                System.out.println("线程运行中: " + Thread.currentThread().getName());
            });
        }
        executor.shutdown();
    }
}

6. 实际应用案例

案例：多线程下载文件

java

import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FileDownloader {
    public static void main(String[] args) {
        String[] urls = {
            "https://example.com/file1.zip",
            "https://example.com/file2.zip"
        };

        ExecutorService executor = Executors.newFixedThreadPool(urls.length);
        for (String url : urls) {
            executor.submit(() -> downloadFile(url));
        }
        executor.shutdown();
    }

    private static void downloadFile(String url) {
        try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream());
             FileOutputStream out = new FileOutputStream(url.substring(url.lastIndexOf("/") + 1))) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(buffer, 0, 1024)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
            System.out.println("下载完成: " + url);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}