当前位置：首页 > news >正文

Java入门（5）--多线程编程

news 2024/11/3 0:56:25

Java多线程编程：掌握并发编程的艺术 🚀

🎯 深入理解Java多线程机制，构建高效的并发应用！

在上一篇文章中，我们学习了Java的集合框架和泛型编程。今天，让我们一起探索Java中另一个强大而复杂的特性：多线程编程。掌握多线程编程将帮助我们构建更高效、响应更快的应用程序！ 💪

1. 多线程基础概念 📚

在开始编写多线程程序之前，我们需要理解一些基本概念：

进程(Process): 一个独立的程序执行实例
线程(Thread): 进程中的执行单元，共享进程资源
并发(Concurrency): 多个任务交替执行
并行(Parallelism): 多个任务同时执行
线程安全(Thread Safety): 多线程环境下程序正确运行的能力

1.1 创建线程的方式

public class ThreadCreationExample {public static void main(String[] args) {// 1. 继承Thread类class MyThread extends Thread {@Overridepublic void run() {System.out.println("使用Thread类创建的线程");}}// 2. 实现Runnable接口class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("使用Runnable接口创建的线程");}}// 启动线程new MyThread().start();new Thread(new MyRunnable()).start();// 3. 使用Lambda表达式（Java 8+）new Thread(() -> {System.out.println("使用Lambda表达式创建的线程");}).start();}
}

1.2 线程生命周期

public class ThreadLifecycleExample {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(() -> {try {System.out.println("线程运行中...");Thread.sleep(2000); // 线程休眠2秒System.out.println("线程恢复运行");} catch (InterruptedException e) {System.out.println("线程被中断");}});System.out.println("线程状态：" + thread.getState()); // NEWthread.start();System.out.println("线程状态：" + thread.getState()); // RUNNABLEThread.sleep(1000);System.out.println("线程状态：" + thread.getState()); // TIMED_WAITINGthread.join(); // 等待线程结束System.out.println("线程状态：" + thread.getState()); // TERMINATED}
}

2. 线程同步与锁机制 🔒

2.1 synchronized关键字

public class SynchronizedExample {private int count = 0;private final Object lock = new Object();// 同步方法public synchronized void increment() {count++;}// 同步代码块public void increment2() {synchronized(lock) {count++;}}public static void main(String[] args) throws InterruptedException {SynchronizedExample example = new SynchronizedExample();// 创建多个线程同时增加计数Thread[] threads = new Thread[10];for (int i = 0; i < 10; i++) {threads[i] = new Thread(() -> {for (int j = 0; j < 1000; j++) {example.increment();}});threads[i].start();}// 等待所有线程完成for (Thread thread : threads) {thread.join();}System.out.println("最终计数：" + example.count);}
}

2.2 Lock接口

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class LockExample {private int count = 0;private final Lock lock = new ReentrantLock();public void increment() {lock.lock();try {count++;} finally {lock.unlock(); // 确保锁被释放}}public void incrementWithTimeout() {try {if (lock.tryLock(1, TimeUnit.SECONDS)) {try {count++;} finally {lock.unlock();}}} catch (InterruptedException e) {Thread.currentThread().interrupt();}}
}

2.3 volatile关键字

public class VolatileExample {private volatile boolean flag = false;public void writer() {flag = true; // 修改后其他线程立即可见}public void reader() {while (!flag) {// 等待flag变为true}// 继续执行}
}

3. 线程池与执行器 🏊‍♂️

import java.util.concurrent.*;public class ThreadPoolExample {public static void main(String[] args) {// 创建固定大小的线程池ExecutorService fixedPool = Executors.newFixedThreadPool(3);// 创建缓存线程池ExecutorService cachedPool = Executors.newCachedThreadPool();// 创建单线程执行器ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();// 提交任务Future<String> future = fixedPool.submit(() -> {Thread.sleep(1000);return "任务完成";});try {String result = future.get(2, TimeUnit.SECONDS);System.out.println(result);} catch (Exception e) {e.printStackTrace();}// 关闭线程池fixedPool.shutdown();}
}

4. 并发集合 📦

import java.util.concurrent.*;
import java.util.concurrent.atomic.*;public class ConcurrentCollectionsExample {public static void main(String[] args) {// 线程安全的ListCopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();// 线程安全的MapConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();// 线程安全的QueueConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();// 阻塞队列BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>();// 原子变量AtomicInteger atomicInt = new AtomicInteger(0);// 并发操作示例ExecutorService executor = Executors.newFixedThreadPool(3);for (int i = 0; i < 10; i++) {executor.submit(() -> {list.add("item");map.put("key" + atomicInt.getAndIncrement(), 1);queue.offer("message");try {blockingQueue.put("blocked-item");} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}executor.shutdown();}
}

5. 实战案例：生产者-消费者模式 🏭

public class ProducerConsumerExample {private static final int BUFFER_SIZE = 10;private static BlockingQueue<Integer> buffer = new ArrayBlockingQueue<>(BUFFER_SIZE);static class Producer implements Runnable {@Overridepublic void run() {try {while (true) {int item = produceItem();buffer.put(item);System.out.println("生产: " + item + ", 缓冲区大小: " + buffer.size());Thread.sleep(100);}} catch (InterruptedException e) {Thread.currentThread().interrupt();}}private int produceItem() {return new Random().nextInt(100);}}static class Consumer implements Runnable {@Overridepublic void run() {try {while (true) {int item = buffer.take();System.out.println("消费: " + item + ", 缓冲区大小: " + buffer.size());Thread.sleep(200);}} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}public static void main(String[] args) {// 启动生产者和消费者ExecutorService executor = Executors.newFixedThreadPool(2);executor.submit(new Producer());executor.submit(new Consumer());}
}