Java(day185)：Java多线程编程与并发控制！

大家好，我是不熬夜崽崽！大家如果觉得看了本文有帮助的话，麻烦给不熬夜崽崽点个三连（点赞、收藏、关注）支持一下哈，大家的支持就是我写作的无限动力。

前言

在现代软件开发中，高并发已成为许多应用系统的常态，尤其是在大规模分布式系统中。Java作为一种广泛应用的编程语言，提供了强大的多线程和并发控制机制，允许开发者高效地利用多核处理器提高应用程序的执行效率。然而，在高并发环境下，管理线程和避免常见的并发问题（如死锁、线程安全问题）依然是一项挑战。

本篇文章将深入探讨Java中的多线程编程，详细分析线程的管理、线程安全与同步机制、常见的并发工具类的使用、如何避免死锁和活锁等问题。同时，本文也会通过实际案例代码展示如何使用这些技术构建高效的多线程系统。

Java中的线程模型与创建线程的方法

1. Java线程模型概述

在Java中，线程是操作系统调度的最小单位。Java通过Thread类和Runnable接口来实现多线程编程。每个线程都有自己的执行路径，多个线程可以并行执行，从而充分利用多核处理器的计算能力。

线程的生命周期：线程的生命周期包括创建、就绪、运行、阻塞、终止等状态，线程的状态可以通过不同的API进行控制和管理。

2. 创建线程的方式

在Java中，我们有两种常见的方式来创建线程：继承Thread类和实现Runnable接口。

通过继承Thread类：

继承Thread类，并重写run()方法。

class MyThread extends Thread {@Overridepublic void run() {System.out.println("Thread is running");}
}public class Main {public static void main(String[] args) {MyThread t = new MyThread();t.start();  // 启动线程}
}

在这种方式中，我们创建一个继承自Thread的类，并在run()方法中定义要执行的任务。调用start()方法会使线程开始执行。

通过实现Runnable接口：

使用Runnable接口的好处是避免了Java的单继承限制，一个类可以实现多个接口。将任务封装到run()方法中，然后将其传递给Thread实例来执行。
```
class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("Thread is running");}
}public class Main {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread t = new Thread(myRunnable);t.start();  // 启动线程}
}
```
在这种方式中，Runnable接口提供了run()方法，任务逻辑写在该方法中。通过将Runnable传递给Thread实例并调用start()，线程开始执行。

通过Callable接口和ExecutorService创建线程：

Callable接口允许线程有返回值，而ExecutorService是一个更高层次的线程池管理工具，适用于管理大量线程。

import java.util.concurrent.*;class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {return "Callable thread result";}
}public class Main {public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executorService = Executors.newSingleThreadExecutor();Future<String> future = executorService.submit(new MyCallable());String result = future.get();  // 获取线程返回的结果System.out.println(result);executorService.shutdown();}
}

使用ExecutorService可以管理线程池，避免手动创建线程。通过submit()方法提交Callable任务，并使用future.get()获取执行结果。

线程安全与同步机制（如`synchronized`、`Lock`等）

1. 线程安全概念

线程安全是指在多线程环境下，多个线程访问共享数据时，程序的行为是正确的，不会发生数据竞争或不一致的情况。在Java中，常用的同步机制有synchronized关键字、Lock接口以及原子类（如AtomicInteger）等。

2. synchronized关键字

synchronized关键字是Java中实现同步的最基本方式。它可以用来修饰方法或者代码块，确保同一时刻只有一个线程能执行被加锁的代码，从而保证数据的线程安全。

同步方法：

使用synchronized修饰方法，确保同一时刻只有一个线程可以执行该方法。
```
class Counter {private int count = 0;public synchronized void increment() {count++;}public synchronized int getCount() {return count;}
}
```
在该例中，increment()方法和getCount()方法被加上synchronized，从而确保在多线程环境下对count的访问是线程安全的。
同步代码块：

使用synchronized修饰代码块，可以细化锁的粒度，提高性能。
```
class Counter {private int count = 0;public void increment() {synchronized (this) {count++;}}public int getCount() {return count;}
}
```
在此代码中，synchronized仅限制对count++这行代码的访问，这样可以减少锁的持有时间，提升性能。

3. Lock接口

Lock接口是Java 5引入的更灵活的同步机制，它提供了比synchronized更多的功能，如可以尝试获取锁、锁中断等。

ReentrantLock的使用：

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;}
}

使用ReentrantLock，我们可以显式地控制锁的获取与释放，避免了synchronized可能造成的性能问题，并且支持可中断的锁操作。

4. 原子类

Java提供了多个原子类（如AtomicInteger、AtomicLong等），它们使用CAS（Compare And Swap）技术来实现无锁的线程安全操作。

使用AtomicInteger：

import java.util.concurrent.atomic.AtomicInteger;class Counter {private AtomicInteger count = new AtomicInteger(0);public void increment() {count.incrementAndGet();}public int getCount() {return count.get();}
}

在该示例中，AtomicInteger类通过CAS实现了无锁的线程安全操作，避免了使用synchronized带来的性能开销。

常见并发工具类的使用：ExecutorService、CountDownLatch、Semaphore等

1. ExecutorService

ExecutorService是Java提供的线程池管理工具，它允许开发者管理线程池并提交异步任务。线程池可以减少线程创建和销毁的开销，提高程序的执行效率。

创建线程池：

ExecutorService executorService = Executors.newFixedThreadPool(10);  // 创建一个固定大小的线程池
executorService.submit(() -> {System.out.println("Task running in thread: " + Thread.currentThread().getName());
});
executorService.shutdown();

使用ExecutorService可以避免手动管理线程的创建和销毁，简化了并发编程的复杂性。

2. CountDownLatch

CountDownLatch用于在多个线程之间同步操作，它允许一个线程等待其他线程完成某些任务后再继续执行。

示例：

class Worker implements Runnable {private CountDownLatch latch;public Worker(CountDownLatch latch) {this.latch = latch;}@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " is working");latch.countDown();  // 完成工作后减计数}
}public class Main {public static void main(String[] args) throws InterruptedException {CountDownLatch latch = new CountDownLatch(3);ExecutorService executorService = Executors.newFixedThreadPool(3);for (int i = 0; i < 3; i++) {executorService.submit(new Worker(latch));}latch.await();  // 等待计数为0，线程继续执行System.out.println("All workers finished!");executorService.shutdown();}
}

在这个例子中，CountDownLatch会等待所有工作线程完成后才执行主线程的后续操作。

3. Semaphore

Semaphore是一种基于计数的同步工具，用于控制多个线程对共享资源的访问，常用于限制并发线程数。

示例：

class Worker implements Runnable {private Semaphore semaphore;public Worker(Semaphore semaphore) {this.semaphore = semaphore;}@Overridepublic void run() {try {semaphore.acquire();  // 获取许可System.out.println(Thread.currentThread().getName() + " is working");Thread.sleep(1000);semaphore.release();  // 释放许可} catch (InterruptedException e) {e.printStackTrace();}}
}public class Main {public static void main(String[] args) {Semaphore semaphore = new Semaphore(2);  // 限制最多2个线程同时访问ExecutorService executorService = Executors.newFixedThreadPool(5);for (int i = 0; i < 5; i++) {executorService.submit(new Worker(semaphore));}executorService.shutdown();}
}

在这个示例中，Semaphore控制最多两个线程同时访问共享资源，其他线程需要等待许可。

死锁与活锁的避免与解决方案

1. 死锁的避免

死锁发生在多个线程相互等待对方释放锁，导致程序无法继续执行。为避免死锁，通常遵循以下原则：

避免嵌套锁：确保所有线程按照相同的顺序获取锁。
锁超时：设置超时时间，避免线程长时间等待锁。

Lock lock1 = new ReentrantLock();
Lock lock2 = new ReentrantLock();public void method1() {lock1.lock();try {lock2.lock();  // 嵌套锁，可能导致死锁} finally {lock1.unlock();}
}

通过确保线程总是按照相同顺序获取锁，可以有效避免死锁。

2. 活锁的避免

活锁指的是线程在不断反应彼此的操作，导致程序无法继续执行。避免活锁的一个方法是增加重试间隔，并避免无限制的重试。

public void tryLockWithDelay() {while (!lock.tryLock()) {// 增加重试间隔，避免活锁try {Thread.sleep(100);  // 暂停一段时间} catch (InterruptedException e) {Thread.currentThread().interrupt();}}
}