Java 学习（五）多线程编程与深入学习 Java 库

最新推荐文章于 2026-06-19 17:00:49 发布

原创最新推荐文章于 2026-06-19 17:00:49 发布 · 1.4k 阅读

8 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#python #java #开发语言

Java 专栏收录该内容

8 篇文章

订阅专栏

在现代的企业级应用中，多线程编程和高效的库使用是提升程序性能和开发效率的关键。Java 的多线程编程使得我们能够高效地利用多核处理器，而 Java 库则为我们提供了各种现成的功能，减少了重复造轮子的工作。本文将深入探讨 Java 的多线程编程以及常用的 Java 库，帮助你更高效地开发高性能应用。

1. Java 多线程编程

Java 提供了强大的多线程编程支持，能够让我们在程序中并行处理任务，从而提高应用的性能和响应速度。Java 的多线程主要通过 Thread 类和 Runnable 接口实现。

1.1 创建线程

在 Java 中，创建线程有两种主要方式：

继承 Thread 类并重写 run() 方法。
实现 Runnable 接口，并将其传递给 Thread 类。

示例 1：继承 `Thread` 类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();  // 启动线程
    }
}

示例 2：实现 `Runnable` 接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable thread is running: " + Thread.currentThread().getName());
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();  // 启动线程
    }
}

解释：

Thread 类和 Runnable 接口都包含一个 run() 方法，线程执行的任务在 run() 方法中定义。
使用 start() 启动线程，而不是直接调用 run()。

1.2 线程同步

在多线程程序中，多个线程可能会同时访问共享资源，导致数据不一致或错误。为了解决这个问题，我们需要使用 线程同步 来保证共享资源的访问是安全的。

示例：使用 `synchronized` 关键字

class Counter {
    private int count = 0;

    // 使用 synchronized 保证线程安全
    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

public class SynchronizedExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

解释：

synchronized 关键字用于确保每次只有一个线程可以访问同步方法或同步块，从而避免并发冲突。
在此示例中，increment() 方法是线程安全的，确保两个线程能够安全地访问 count 变量。

1.3 `ExecutorService` 与线程池

直接创建和管理线程在实际开发中不太方便且效率低下。Java 提供了 ExecutorService 接口来管理线程池，避免了频繁的线程创建和销毁开销。

示例：使用线程池

import java.util.concurrent.*;

public class ExecutorServiceExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        Callable<Integer> task = () -> {
            Thread.sleep(1000);
            return 100;
        };

        Future<Integer> future = executorService.submit(task);
        Integer result = future.get();  // 阻塞直到任务完成

        System.out.println("Result: " + result);
        executorService.shutdown();  // 关闭线程池
    }
}

解释：

使用 Executors.newFixedThreadPool(2) 创建一个包含 2 个线程的线程池。
submit() 方法提交任务并返回一个 Future 对象，get() 方法用于获取任务的返回值，且会阻塞直到任务完成。

1.4 线程安全类与并发工具类

Java 提供了多种线程安全类和并发工具类（位于 java.util.concurrent 包中），例如 CopyOnWriteArrayList、AtomicInteger、CountDownLatch 等，它们提供了更为高级的并发控制。

示例：使用 `AtomicInteger` 实现原子操作

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.incrementAndGet();  // 原子递增
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();

        System.out.println("Final count: " + counter.get());
    }
}

解释：

AtomicInteger 提供了原子操作，避免了同步的开销，适用于某些简单的计数任务。

2. 深入学习 Java 库

Java 提供了丰富的标准库，涵盖了文件处理、网络编程、数据库访问、并发处理等多个方面。通过掌握常用的 Java 库，能够大大提高我们的开发效率。

2.1 `java.util` 包

java.util 包是 Java 中最常用的包之一，包含了集合类、日期时间类、随机数生成器等。

示例：使用 `ArrayList` 和 `HashMap`

import java.util.*;

public class UtilExample {
    public static void main(String[] args) {
        // 使用 ArrayList
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // 使用 HashMap
        Map<String, Integer> fruitPrices = new HashMap<>();
        fruitPrices.put("Apple", 2);
        fruitPrices.put("Banana", 1);
        fruitPrices.put("Cherry", 3);

        // 遍历 ArrayList
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 遍历 HashMap
        for (Map.Entry<String, Integer> entry : fruitPrices.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

解释：

ArrayList 是一个动态数组实现，适用于需要频繁访问和修改元素的场景。
HashMap 用于存储键值对，适合用来快速查找数据。

2.2 `java.nio` 包（新 I/O）

Java NIO 提供了比传统 I/O 更高效的文件操作、缓冲区和通道。

示例：使用 NIO 进行文件读取

import java.nio.file.*;
import java.io.IOException;

public class NIOFileExample {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");

        try {
            Files.write(path, "Hello, NIO!".getBytes(), StandardOpenOption.CREATE);
            String content = new String(Files.readAllBytes(path));
            System.out.println(content);  // 输出: Hello, NIO!
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

解释：

Files 类提供了许多静态方法用于文件操作，简化了文件读写的操作。
NIO 使用 Path 和 Files 对象进行文件管理，比传统的 File 类更加灵活和高效。

2.3 `java.sql` 包（数据库访问）

Java 提供了 java.sql 包来进行数据库连接和操作。常见的类有 Connection、Statement、PreparedStatement、ResultSet 等。

示例：使用 JDBC 访问数据库

import java.sql.*;

public class JDBCExample {
    public static void main(String[] args) {
        try {
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "root", "password");
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM users");

            while (rs.next()) {
                System.out.println("User ID: " + rs.getInt("id"));
                System.out.println("User Name: " + rs.getString("name"));
            }

            rs.close();
            stmt.close();
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

解释：