Java 多线程与并发编程是 Java 工程师必须掌握的重要技能之一。随着计算机硬件性能的不断提升，多核 CPU 成为主流，开发高并发应用已成为越来越重要的需求。本文将介绍 Java 多线程与并发编程的基本概念和技术，包括线程、锁、同步机制、线程池、并发集合和并发编程的实践案例。
(资料图片)
线程
线程是进程的一部分，是程序执行的最小单位。Java 中的线程是通过 Thread 类实现的。在 Java 中，线程有五个状态：新建状态、就绪状态、运行状态、阻塞状态和终止状态。通常使用 start 方法启动一个新线程，使用 join 方法等待线程执行完毕，使用 sleep 方法暂停线程的执行。以下是一个简单的线程实例：
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("Hello from thread " + Thread.currentThread().getName());
}
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.start();
thread2.start();
}
}
锁和同步机制
在多线程编程中，需要使用锁和同步机制来保证线程安全。
Java 中提供了多种锁和同步机制，包括 synchronized 关键字、ReentrantLock 类、CountDownLatch 类、Semaphore 类等。
synchronized 关键字是 Java 中最常用的同步机制，可以用来保护临界区资源的访问，防止多个线程同时访问造成数据不一致的问题。以下是一个使用 synchronized 实现线程安全的计数器的例子：
public class Counter {
private int count;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
ReentrantLock 类是一个可重入锁，它提供了与 synchronized 关键字相似的同步功能，但更加灵活和可控。
以下是一个使用 ReentrantLock 实现线程安全的计数器的例子：
public class Counter {
private int count;
private ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
}
线程池
线程池是多线程编程中的一种常用技术，它可以管理和复用线程，提高程序的性能和可维护性。
Java 中提供了 Executor 框架和 ThreadPoolExecutor 类来实现线程池。以下是一个使用 ThreadPoolExecutor 实现的线程池例子：
public public class ThreadPoolExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
for (int i = 0; i < 10; i++) {
executor.execute(new WorkerThread("Thread " + i));
}
executor.shutdown();
while (!executor.isTerminated()) {
// 等待线程池中的任务执行完毕
}
System.out.println("All threads have been terminated.");
}
}
class WorkerThread implements Runnable {
private String name;
public WorkerThread(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println("Start executing thread " + name);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Finish executing thread " + name);
}
}
并发集合
Java 提供了一些并发集合类，例如 ConcurrentHashMap、ConcurrentLinkedQueue、CopyOnWriteArrayList 等，用于在多线程环境下安全地读写数据。这些集合类采用了一些特殊的技术，例如分段锁、CAS（Compare And Swap）等，来保证线程安全。
以下是一个使用 ConcurrentHashMap 实现的线程安全的计数器例子：
public class ConcurrentCounter {
private ConcurrentHashMap<String, Integer> counter = new ConcurrentHashMap<>();
public void increment(String key) {
counter.compute(key, (k, v) -> v == null ? 1 : v + 1);
}
public int getCount(String key) {
return counter.get(key);
}
}
并发编程实践
下面介绍一个简单的并发编程实践：多线程下载器。该下载器使用多个线程同时下载一个文件，从而加快下载速度。
public class MultiThreadDownloader {
private URL url;
private int threadCount;
public MultiThreadDownloader(String urlString, int threadCount) throws MalformedURLException {
this.url = new URL(urlString);
this.threadCount = threadCount;
}
public void download() throws IOException, InterruptedException {
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
int fileSize = connection.getContentLength();
connection.disconnect();
int blockSize = fileSize / threadCount + 1;
CountDownLatch latch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
int start = i * blockSize;
int end = Math.min((i + 1) * blockSize - 1, fileSize - 1);
new DownloadThread(url, start, end, latch).start();
}
latch.await();
System.out.println("Download completed.");
}
public static void main(String[] args) throws IOException, InterruptedException {
MultiThreadDownloader downloader = new MultiThreadDownloader("https://www.example.com/file.txt", 4);
downloader.download();
}
}
class DownloadThread extends Thread {
private URL url;
private int start;
private int end;
private CountDownLatch latch;
public DownloadThread(URL url, int start, int end, CountDownLatch latch) {
this.url = url;
this.start = start;
this.end = end;
this.latch = latch;
}
@Override
public void run() {
try {
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestProperty("Range", "bytes=" + start + "-" + end);
InputStream in = connection.getInputStream();
FileOutputStream out = new FileOutputStream("file.txt", true);
byte[] buffer = new byte[4096];
int len;
while ((len = in.read(buffer)) != -1) {
out.write(buffer, 0, len);
}
in.close();
out.close();
connection.disconnect();
System.out.println("Downloaded bytes " + start + "-" + end + ".");
} catch (IOException e) {
e.printStackTrace();
} finally {
latch.countDown();
}
}
}
在主函数中，我们创建了一个 MultiThreadDownloader 对象，指定了下载文件的 URL 和线程数。
download 方法中，首先发送一个 HEAD 请求获取文件大小，然后根据线程数计算出每个线程下载的数据块大小。
接下来，使用 CountDownLatch 来控制所有线程的执行，创建 threadCount 个 DownloadThread 对象，并启动它们。
每个 DownloadThread 对象都指定了下载数据的起始位置和终止位置，以及一个 CountDownLatch 对象。
DownloadThread 的 run 方法中，首先发送一个 GET 请求，指定下载数据的范围，然后将数据写入本地文件，并计数器减一。最后在主函数中等待所有线程执行完毕。
总结
本文简单介绍了 Java 多线程与并发编程的基础知识和常用技术。
在实际开发中，需要根据具体的场景选择合适的并发模型和工具，避免出现死锁、竞态条件等并发问题，从而实现高效、安全的多线程编程。