一条龙看下来，加深 你对多线程的理解 和 实际运用能力。
简介
Java 的多线程是 Java 平台的核心特性之一，它允许并发执行多个任务，从而提高程序的响应能力和整体性能。Java 多线程主要通过 Thread 类和 Runnable 接口来实现。下面详细介绍 Java 多线程的基本概念、实现方式、生命周期、同步机制等方面的知识。
1. Java 多线程的基本概念
1.1 线程与进程
- 进程：是操作系统分配资源的基本单位，每个进程都有独立的内存空间。
- 线程：是进程内的一个执行单元，同一进程中的线程共享进程的内存空间，线程间的通信更为高效。
1.2 线程的好处
- 提高系统响应性：可以实现用户界面与后台处理的并发执行，使得程序即使在处理耗时操作时也能保持响应。
- 提高性能：充分利用多核处理器的能力，同时处理多个任务。
2. 创建线程的两种方式
2.1 继承 Thread 类
可以通过继承 Thread 类并重写 run() 方法来创建线程。
1class MyThread extends Thread {
2 @Override
3 public void run() {
4 System.out.println("Thread running...");
5 }
6
7 public static void main(String[] args) {
8 MyThread thread = new MyThread();
9 thread.start(); // 启动线程
10 }
11}2.2 实现 Runnable 接口
也可以实现 Runnable 接口，并将其实例作为参数传递给 Thread 的构造函数。
1class MyRunnable implements Runnable {
2 @Override
3 public void run() {
4 System.out.println("Runnable running...");
5 }
6
7 public static void main(String[] args) {
8 Thread thread = new Thread(new MyRunnable());
9 thread.start();
10 }
11}3. 线程的生命周期
线程的生命周期包括以下几个阶段：
- 新建 (
NEW)：当一个线程对象被创建但尚未启动时。 - 就绪 (
RUNNABLE)：线程被启动后，等待 CPU 时间片。 - 运行 (
RUNNABLE)：线程获得了 CPU 时间片并开始执行。 - 阻塞 (
BLOCKED)：线程因等待某种条件（如 I/O 操作或同步锁）而暂时停止运行。 - 等待/休眠 (
WAITING)：线程因等待特定事件的发生（如wait()方法）而暂停运行。 - 定时等待 (
TIMED_WAITING)：线程因等待一定时间（如sleep()方法）而暂停运行。 - 终止 (
TERMINATED)：线程执行完毕或被异常终止。
4. 线程同步
4.1 同步锁
为了保证多线程环境下对共享资源的正确访问，可以使用同步锁（Synchronized）来保护临界区。
1public class Counter {
2 private int count = 0;
3
4 public synchronized void increment() {
5 count++;
6 }
7
8 public synchronized int getCount() {
9 return count;
10 }
11}4.2 volatile 关键字
volatile 关键字可以用来标记一个变量是共享的，确保了对变量的可见性和禁止指令重排。
1public class Counter {
2 private volatile int count = 0;
3
4 public void increment() {
5 count++;
6 }
7
8 public int getCount() {
9 return count;
10 }
11}4.3 Lock 接口
Lock 接口提供了更灵活的锁定机制，可以实现更复杂的同步策略。
1import java.util.concurrent.locks.Lock;
2import java.util.concurrent.locks.ReentrantLock;
3
4public class Counter {
5 private int count = 0;
6 private final Lock lock = new ReentrantLock();
7
8 public void increment() {
9 lock.lock();
10 try {
11 count++;
12 } finally {
13 lock.unlock();
14 }
15 }
16
17 public int getCount() {
18 return count;
19 }
20}5. 线程间通信
5.1 wait() 和 notify()
wait() 和 notify() 方法可以用来实现线程间的通信。
1public class Counter {
2 private int count = 0;
3 private final Object monitor = new Object();
4
5 public void increment() {
6 synchronized (monitor) {
7 count++;
8 monitor.notify();
9 }
10 }
11
12 public void decrement() {
13 synchronized (monitor) {
14 while (count == 0) {
15 try {
16 monitor.wait();
17 } catch (InterruptedException e) {
18 e.printStackTrace();
19 }
20 }
21 count--;
22 }
23 }
24}5.2 生产者-消费者模式
生产者-消费者模式是一种经典的线程协作模型，通过队列来实现生产者和消费者之间的解耦。
1import java.util.concurrent.BlockingQueue;
2import java.util.concurrent.LinkedBlockingQueue;
3
4public class ProducerConsumerDemo {
5 private static final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);
6
7 public static void main(String[] args) {
8 Thread producer = new Thread(() -> {
9 try {
10 for (int i = 0; i < 100; i++) {
11 queue.put(i);
12 System.out.println("Produced: " + i);
13 }
14 } catch (InterruptedException e) {
15 e.printStackTrace();
16 }
17 });
18
19 Thread consumer = new Thread(() -> {
20 try {
21 for (int i = 0; i < 100; i++) {
22 int item = queue.take();
23 System.out.println("Consumed: " + item);
24 }
25 } catch (InterruptedException e) {
26 e.printStackTrace();
27 }
28 });
29
30 producer.start();
31 consumer.start();
32 }
33}6. 线程池
线程池可以有效地管理线程，避免频繁创建和销毁线程所带来的开销。
1import java.util.concurrent.ExecutorService;
2import java.util.concurrent.Executors;
3
4public class ThreadPoolDemo {
5 public static void main(String[] args) {
6 ExecutorService executor = Executors.newFixedThreadPool(5);
7
8 for (int i = 0; i < 10; i++) {
9 executor.submit(() -> {
10 System.out.println(Thread.currentThread().getName() + " is running");
11 });
12 }
13
14 executor.shutdown();
15 }
16}7. 线程中断
线程中断是一种通知线程终止的方式。
1public class ThreadInterruptDemo {
2 public static void main(String[] args) throws InterruptedException {
3 Thread thread = new Thread(() -> {
4 try {
5 while (!Thread.currentThread().isInterrupted()) {
6 Thread.sleep(1000);
7 System.out.println("Running...");
8 }
9 } catch (InterruptedException e) {
10 System.out.println("Interrupted!");
11 Thread.currentThread().interrupt(); // 重置中断标志
12 }
13 });
14
15 thread.start();
16 Thread.sleep(5000);
17 thread.interrupt();
18 }
19}8. 线程安全的容器
Java 提供了一些线程安全的容器类，如 Vector、ConcurrentHashMap 等。
1import java.util.concurrent.ConcurrentHashMap;
2
3public class ThreadSafeContainerDemo {
4 private static ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
5
6 public static void main(String[] args) {
7 Thread t1 = new Thread(() -> {
8 for (int i = 0; i < 100; i++) {
9 map.put(i, "Value " + i);
10 }
11 });
12
13 Thread t2 = new Thread(() -> {
14 for (int i = 0; i < 100; i++) {
15 map.remove(i);
16 }
17 });
18
19 t1.start();
20 t2.start();
21 }
22}总结
Java 的多线程机制提供了丰富的功能，使得开发人员能够编写高性能、高响应性的程序。然而，多线程编程也带来了复杂性和挑战，特别是线程安全和死锁等问题。合理的使用同步机制和设计模式可以有效地解决这些问题。
多线程 运用场景（含代码案例）
Java 多线程的实际运用场景非常广泛，几乎涵盖了所有需要并发处理的任务。以下是几个典型的应用场景，展示了多线程如何帮助提高程序的性能和响应能力。
1. 用户界面（GUI）应用程序
在 GUI 应用程序中，多线程可以用来分离用户界面的更新和后台任务的执行，以保持 UI 的响应性。
示例：文件下载
在下载大文件时，如果不使用多线程，整个应用程序可能会变得无响应。通过使用多线程，可以让一个线程负责文件下载，另一个线程更新进度条。
1import javax.swing.*;
2import java.awt.*;
3import java.io.InputStream;
4import java.net.URL;
5import java.nio.file.Files;
6import java.nio.file.Path;
7import java.nio.file.Paths;
8
9public class FileDownloader extends JFrame {
10
11 private JButton downloadButton;
12 private JProgressBar progressBar;
13
14 public FileDownloader() {
15 super("File Downloader");
16 downloadButton = new JButton("Download");
17 progressBar = new JProgressBar();
18 progressBar.setStringPainted(true);
19
20 downloadButton.addActionListener(e -> {
21 new Thread(() -> {
22 downloadButton.setEnabled(false);
23 try {
24 URL url = new URL("http://example.com/largefile.zip");
25 InputStream in = url.openStream();
26 Path tempFile = Paths.get("tempfile.zip");
27
28 Files.copy(in, tempFile);
29
30 int totalSize = (int) Files.size(tempFile);
31 long downloaded = 0;
32 Files.newByteChannel(tempFile).position(0);
33
34 byte[] buffer = new byte[1024];
35 int read;
36 while ((read = in.read(buffer)) != -1) {
37 downloaded += read;
38 Files.write(tempFile, buffer, 0, read);
39 updateProgress(downloaded, totalSize);
40 }
41 JOptionPane.showMessageDialog(FileDownloader.this, "Download Complete!");
42 } catch (Exception ex) {
43 JOptionPane.showMessageDialog(FileDownloader.this, "Error: " + ex.getMessage());
44 } finally {
45 downloadButton.setEnabled(true);
46 }
47 }).start();
48 });
49
50 setLayout(new BorderLayout());
51 add(downloadButton, BorderLayout.NORTH);
52 add(progressBar, BorderLayout.CENTER);
53 pack();
54 setLocationRelativeTo(null);
55 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
56 setVisible(true);
57 }
58
59 private void updateProgress(long downloaded, int totalSize) {
60 SwingUtilities.invokeLater(() -> {
61 progressBar.setValue((int) (downloaded * 100 / totalSize));
62 });
63 }
64
65 public static void main(String[] args) {
66 EventQueue.invokeLater(() -> {
67 new FileDownloader();
68 });
69 }
70}2. 网络编程
在网络编程中，多线程可以用来处理多个客户端的连接请求，提高服务器的并发处理能力。
示例：简单的 HTTP 服务器
一个简单的 HTTP 服务器可以使用多线程来处理每个客户端的请求。
1import java.io.*;
2import java.net.ServerSocket;
3import java.net.Socket;
4
5public class SimpleHttpServer {
6
7 public static void main(String[] args) {
8 try (ServerSocket serverSocket = new ServerSocket(8080)) {
9 System.out.println("Server started on port 8080");
10
11 while (true) {
12 Socket clientSocket = serverSocket.accept();
13 new Thread(() -> handleClient(clientSocket)).start();
14 }
15 } catch (IOException e) {
16 System.err.println("Error starting server: " + e.getMessage());
17 }
18 }
19
20 private static void handleClient(Socket clientSocket) {
21 try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
22 PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
23
24 String line;
25 while (!(line = in.readLine()).isEmpty()) {
26 System.out.println(line);
27 }
28
29 out.println("HTTP/1.1 200 OK");
30 out.println("Content-Type: text/html");
31 out.println();
32 out.println("<html><body>Hello, World!</body></html>");
33 } catch (IOException e) {
34 System.err.println("Error handling client: " + e.getMessage());
35 }
36 }
37}3. 数据处理与批处理
在数据处理或批处理任务中，多线程可以用来并行处理数据集，加快处理速度。
示例：批量图片压缩
使用多线程来并行处理图片压缩任务，提高处理速度。
1import java.awt.image.BufferedImage;
2import java.io.File;
3import java.io.IOException;
4import javax.imageio.ImageIO;
5
6public class ImageCompressor {
7
8 public static void main(String[] args) {
9 String[] images = {"image1.jpg", "image2.jpg", "image3.jpg"};
10 for (String image : images) {
11 new Thread(() -> compressImage(image)).start();
12 }
13 }
14
15 private static void compressImage(String imagePath) {
16 try {
17 BufferedImage originalImage = ImageIO.read(new File(imagePath));
18 BufferedImage compressedImage = new BufferedImage(
19 originalImage.getWidth(),
20 originalImage.getHeight(),
21 BufferedImage.TYPE_INT_RGB
22 );
23 compressedImage.getGraphics().drawImage(originalImage, 0, 0, null);
24 ImageIO.write(compressedImage, "jpg", new File(imagePath + ".compressed"));
25 System.out.println("Compressed: " + imagePath);
26 } catch (IOException e) {
27 System.err.println("Error compressing image: " + e.getMessage());
28 }
29 }
30}4. 数据库操作
在处理数据库操作时，多线程可以用来并行执行查询或更新操作，提高处理效率。
示例：批量插入数据库
使用多线程来并行执行数据库插入操作。
1import java.sql.Connection;
2import java.sql.DriverManager;
3import java.sql.PreparedStatement;
4import java.sql.SQLException;
5
6public class BatchDatabaseInsert {
7
8 private static final String DB_URL = "jdbc:mysql://localhost:3306/mydb";
9 private static final String USER = "username";
10 private static final String PASS = "password";
11
12 public static void main(String[] args) {
13 String[] records = {"John Doe", "Jane Smith", "Alice Johnson"};
14 Connection conn = null;
15
16 try {
17 conn = DriverManager.getConnection(DB_URL, USER, PASS);
18 for (String record : records) {
19 new Thread(() -> insertRecord(conn, record)).start();
20 }
21 } catch (SQLException e) {
22 System.err.println("Error connecting to database: " + e.getMessage());
23 } finally {
24 if (conn != null) {
25 try {
26 conn.close();
27 } catch (SQLException e) {
28 System.err.println("Error closing connection: " + e.getMessage());
29 }
30 }
31 }
32 }
33
34 private static void insertRecord(Connection conn, String record) {
35 String sql = "INSERT INTO users (name) VALUES (?)";
36 try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
37 pstmt.setString(1, record);
38 pstmt.executeUpdate();
39 System.out.println("Inserted: " + record);
40 } catch (SQLException e) {
41 System.err.println("Error inserting record: " + e.getMessage());
42 }
43 }
44}5. 多媒体处理
在多媒体处理中，多线程可以用来并行处理音频或视频流，提高处理速度。
示例：视频转码
使用多线程来并行处理视频转码任务。
1import java.io.File;
2
3public class VideoTranscoder {
4
5 public static void main(String[] args) {
6 String[] videos = {"video1.mp4", "video2.mp4", "video3.mp4"};
7 for (String video : videos) {
8 new Thread(() -> transcodeVideo(video)).start();
9 }
10 }
11
12 private static void transcodeVideo(String videoPath) {
13 try {
14 ProcessBuilder pb = new ProcessBuilder("ffmpeg", "-i", videoPath, "-vcodec", "libx264", "-crf", "23", videoPath + ".transcoded");
15 Process process = pb.start();
16 process.waitFor();
17 System.out.println("Transcoded: " + videoPath);
18 } catch (IOException | InterruptedException e) {
19 System.err.println("Error transcoding video: " + e.getMessage());
20 }
21 }
22}6. 网络爬虫
在构建网络爬虫时，多线程可以用来并行抓取网页，提高抓取速度。
示例：简单的网络爬虫
使用多线程来并行抓取网页内容。
1import java.io.BufferedReader;
2import java.io.InputStreamReader;
3import java.net.URL;
4import java.util.concurrent.ExecutorService;
5import java.util.concurrent.Executors;
6
7public class SimpleWebCrawler {
8
9 public static void main(String[] args) {
10 String[] urls = {"http://example.com", "http://google.com", "http://yahoo.com"};
11 ExecutorService executor = Executors.newFixedThreadPool(5);
12
13 for (String url : urls) {
14 executor.submit(() -> fetchPage(url));
15 }
16
17 executor.shutdown();
18 }
19
20 private static void fetchPage(String url) {
21 try (BufferedReader reader = new BufferedReader(new InputStreamReader(new URL(url).openStream()))) {
22 String line;
23 while ((line = reader.readLine()) != null) {
24 System.out.println(line);
25 }
26 System.out.println("Fetched: " + url);
27 } catch (Exception e) {
28 System.err.println("Error fetching page: " + e.getMessage());
29 }
30 }
31}总结
多线程在 Java 中有着广泛的应用，它可以帮助我们构建高性能、高响应性的应用程序。通过合理地使用多线程，可以显著提高程序的执行效率，并解决许多并发编程中的挑战。无论是在 GUI 应用程序、网络编程、数据处理还是多媒体处理等领域，多线程都是不可或缺的技术。
扫一扫
1422
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
