AI 助理
备案控制台
开发者社区 计算巢 文章 正文

Java 多线程并发控制：深入理解与实战应用

2024-11-22 20
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 《Java多线程并发控制：深入理解与实战应用》一书详细解析了Java多线程编程的核心概念、并发控制技术及其实战技巧，适合Java开发者深入学习和实践参考。

一、引言

在现代软件开发中，尤其是在处理复杂的任务和提高系统性能方面，多线程技术扮演着极为重要的角色。Java 作为一种广泛应用的编程语言，提供了强大的多线程支持。然而，多线程编程也带来了一系列的挑战，如线程安全、资源竞争、死锁等问题。本文将深入探讨 Java 多线程并发控制的核心技术点，包括线程的创建与启动、线程同步机制、线程间通信以及如何避免常见的并发问题，并通过实际的代码示例和案例分析来帮助读者更好地理解和应用这些知识。

二、线程的创建与启动

  1. 继承 Thread 类
    • 定义一个类继承自 Thread 类，并重写 run 方法。在 run 方法中编写线程要执行的任务逻辑。例如：
      class MyThread extends Thread {
       
@Override
public void run() {
       
   for (int i = 0; i < 10; i++) {
       
       System.out.println("MyThread: " + i);
   }
}
}
    • 然后在主线程中创建并启动该线程：
      public class Main {
       
public static void main(String[] args) {
       
   MyThread thread = new MyThread();
   thread.start();
   for (int i = 0; i < 10; i++) {
       
       System.out.println("Main Thread: " + i);
   }
}
}
    • 这里需要注意的是，直接调用 thread.run() 并不会启动新的线程，而是在当前线程（主线程）中执行 run 方法。只有调用 thread.start() 才会真正创建并启动一个新的线程，使 run 方法在新线程中异步执行。
  2. 实现 Runnable 接口
    • 定义一个类实现 Runnable 接口，实现 run 方法。例如：
      class MyRunnable implements Runnable {
       
@Override
public void run() {
       
   for (int i = 0; i < 10; i++) {
       
       System.out.println("MyRunnable: " + i);
   }
}
}
    • 在主线程中创建 Runnable 实例，并将其作为参数传递给 Thread 类的构造函数来创建线程并启动：
      public class Main {
       
public static void main(String[] args) {
       
   MyRunnable runnable = new MyRunnable();
   Thread thread = new Thread(runnable);
   thread.start();
   for (int i = 0; i < 10; i++) {
       
       System.out.println("Main Thread: " + i);
   }
}
}
    • 这种方式更加灵活，因为一个 Runnable 实例可以被多个线程共享，实现资源的复用。

三、线程同步机制

  1. synchronized 关键字
    • 同步方法：在方法声明前加上 synchronized 关键字，该方法在同一时刻只能被一个线程访问。例如：
      class Counter {
       
private int count = 0;
public synchronized void increment() {
       
   count++;
}
public int getCount() {
       
   return count;
}
}
    • 当多个线程同时调用 increment 方法时，只有一个线程能够进入该方法执行，其他线程会被阻塞，直到当前线程执行完毕。
    • 同步代码块：可以对代码块进行同步，指定一个对象作为锁。例如：
      class SharedResource {
       
private Object lock = new Object();
private int value = 0;
public void modifyValue() {
       
   synchronized (lock) {
       
       value++;
   }
}
}
    • 这里 lock 对象作为锁，只有获得该锁的线程才能执行同步代码块中的 value++ 操作。
  2. ReentrantLock 类
    • ReentrantLock 是一种可重入的互斥锁，提供了比 synchronized 关键字更灵活的锁控制。例如：
      ```java
      import java.util.concurrent.locks.ReentrantLock;

class LockCounter {
private ReentrantLock lock = new ReentrantLock();
private int count = 0;
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
return count;
}
}

   - 线程在访问 `increment` 方法时，首先通过 `lock.lock()` 获取锁，如果锁已被其他线程持有，则当前线程会被阻塞。在操作完成后，必须在 `finally` 块中通过 `lock.unlock()` 释放锁，以确保锁资源的正确释放，防止死锁和资源泄漏。

## 四、线程间通信
1. **wait()、notify() 和 notifyAll() 方法**
   - 这些方法用于在多线程环境下实现线程间的通信，通常与 `synchronized` 关键字配合使用。例如，有一个生产者 - 消费者模型：
```java
import java.util.LinkedList;
import java.util.Queue;

class ProducerConsumer {
    private Queue<Integer> queue = new LinkedList<>();
    private int capacity = 5;

    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            synchronized (this) {
                while (queue.size() == capacity) {
                    wait();
                }
                queue.add(value++);
                System.out.println("Produced: " + value);
                notifyAll();
                Thread.sleep(1000);
            }
        }
    }

    public void consume() throws InterruptedException {
        while (true) {
            synchronized (this) {
                while (queue.isEmpty()) {
                    wait();
                }
                int value = queue.poll();
                System.out.println("Consumed: " + value);
                notifyAll();
                Thread.sleep(2000);
            }
        }
    }
}
  • 在生产者线程中，当队列已满时，调用 wait() 方法使线程进入等待状态，释放锁资源。当消费者从队列中取出元素后，调用 notifyAll() 方法唤醒所有等待的线程（包括其他生产者和消费者线程）。消费者线程的逻辑类似，当队列为空时等待，有元素时消费并通知其他线程。
    1. BlockingQueue 接口
  • Java 提供了 BlockingQueue 接口及其实现类，如 ArrayBlockingQueue、LinkedBlockingQueue 等，用于方便地实现生产者 - 消费者模式等线程间通信场景。例如：
    ```java
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;

class BlockingQueueProducerConsumer {
private BlockingQueue queue = new LinkedBlockingQueue<>();

public void produce() throws InterruptedException {
    int value = 0;
    while (true) {
        queue.put(value++);
        System.out.println("Produced: " + value);
        Thread.sleep(1000);
    }
}

public void consume() throws InterruptedException {
    while (true) {
        int value = queue.take();
        System.out.println("Consumed: " + value);
        Thread.sleep(2000);
    }
}

}

   - `BlockingQueue` 内部已经实现了线程安全的入队和出队操作，并在队列为空或已满时自动阻塞线程，简化了线程间通信的代码实现。

## 五、避免常见的并发问题
1. **死锁**
   - 死锁是多线程编程中常见的问题，当多个线程相互等待对方释放资源时就会发生死锁。例如：
```java
import java.util.concurrent.locks.ReentrantLock;

class DeadlockExample {
    private ReentrantLock lock1 = new ReentrantLock();
    private ReentrantLock lock2 = new ReentrantLock();

    public void method1() {
        lock1.lock();
        try {
            Thread.sleep(100);
            lock2.lock();
            try {
                // 执行一些操作
            } finally {
                lock2.unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock1.unlock();
        }
    }

    public void method2() {
        lock2.lock();
        try {
            Thread.sleep(100);
            lock1.lock();
            try {
                // 执行一些操作
            } finally {
                lock1.unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock2.unlock();
        }
    }
}

  • 在这个例子中，如果一个线程先调用 method1，获取了 lock1，然后另一个线程调用 method2，获取了 lock2，此时两个线程都会进入等待对方释放锁的状态，从而导致死锁。为了避免死锁，可以采用资源有序分配、避免嵌套锁等策略。例如，始终按照相同的顺序获取锁资源：

    class DeadlockAvoidanceExample {
     
private ReentrantLock lock1 = new ReentrantLock();
private ReentrantLock lock2 = new ReentrantLock();

public void method1() {
     
   lock1.lock();
   try {
     
       Thread.sleep(100);
       lock2.lock();
       try {
     
           // 执行一些操作
       } finally {
     
           lock2.unlock();
       }
   } catch (InterruptedException e) {
     
       e.printStackTrace();
   } finally {
     
       lock1.unlock();
   }
}

public void method2() {
     
   lock1.lock();
   try {
     
       Thread.sleep(100);
       lock2.lock();
       try {
     
           // 执行一些操作
       } finally {
     
           lock2.unlock();
       }
   } catch (InterruptedException e) {
     
       e.printStackTrace();
   } finally {
     
       lock1.unlock();
   }
}
}
    1. 资源竞争
  • 资源竞争是指多个线程同时访问共享资源时可能导致数据不一致或错误的情况。除了使用同步机制（如 synchronized 和 ReentrantLock）来保护共享资源外，还可以采用原子类来处理一些简单的原子操作。例如，AtomicInteger 类：
    ```java
    import java.util.concurrent.atomic.AtomicInteger;

class AtomicCounter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet();
}
public int getCount() {
return count.get();
}
}
```

  • AtomicInteger 类通过原子操作来保证 count 的自增操作是线程安全的，避免了使用显式锁带来的一些性能开销和复杂性。

六、总结

Java 多线程并发控制是一个复杂而又重要的领域。通过深入理解线程的创建与启动方式、掌握线程同步机制、熟悉线程间通信的方法以及学会避免常见的并发问题，开发者能够更好地利用多线程技术来提高程序的性能和响应性。在实际项目开发中，需要根据具体的需求和场景，合理选择合适的多线程技术和并发控制策略，同时要充分考虑代码的可读性、可维护性和性能优化。不断地实践和积累经验，才能在 Java 多线程并发编程中得心应手，构建出高效、稳定的多线程应用程序。

文章标签：
Java
安全
开发者
java的细水长流
目录
相关文章
陈佳烨
|
5月前
|
Java
Java中多线程的基本概念、实现方式及其应用
Java中多线程的基本概念、实现方式及其应用
陈佳烨
42 1
sunrr
|
4月前
|
算法 Java UED
Java中如何实现多线程？
【7月更文挑战第10天】Java中如何实现多线程？
sunrr
30 1
杰哥在此
|
4月前
|
设计模式 安全 Java
Java面试题：请解释Java中的线程池以及为什么要使用线程池？请解释Java中的内存模型以及如何避免内存泄漏？请解释Java中的并发工具包以及如何实现一个简单的线程安全队列？
Java面试题：请解释Java中的线程池以及为什么要使用线程池？请解释Java中的内存模型以及如何避免内存泄漏？请解释Java中的并发工具包以及如何实现一个简单的线程安全队列？
杰哥在此
44 1
weixin_836869520
|
4月前
|
安全 Java
解决Java中多线程同步问题的方案
解决Java中多线程同步问题的方案
weixin_836869520
59 0
心安喜乐
|
6月前
|
Java
Java中多线程的常见实现方式
Java中多线程的常见实现方式
心安喜乐
38 2
我不是游客20240119
|
6月前
|
安全 算法 Java
Java中的多线程并发控制
【4月更文挑战第13天】在现代软件开发中，多线程编程已成为提高应用程序性能和响应能力的关键手段。Java作为一门广泛使用的编程语言，提供了丰富的并发控制机制来管理多线程。本文深入探讨了Java中的多线程实现，包括线程的创建与启动、同步机制、死锁问题以及高级并发工具类，旨在为开发者提供有效的多线程并发控制策略。
我不是游客20240119
43 1
xiaohua616
|
6月前
|
Java
Java 多线程实现方式
Java 多线程实现方式
xiaohua616
18 0
技术混子
|
6月前
|
Java 开发者
Java中多线程并发控制的实现与优化
【4月更文挑战第17天】 在现代软件开发中，多线程编程已成为提升应用性能和响应能力的关键手段。特别是在Java语言中，由于其平台无关性和强大的运行时环境，多线程技术的应用尤为广泛。本文将深入探讨Java多线程的并发控制机制，包括基本的同步方法、死锁问题以及高级并发工具如java.util.concurrent包的使用。通过分析多线程环境下的竞态条件、资源争夺和线程协调问题，我们提出了一系列实现和优化策略，旨在帮助开发者构建更加健壮、高效的多线程应用。
技术混子
64 0
程序员三木
|
6月前
|
数据采集 人工智能 Java
6. `Java` 并发基础之`ReentrantReadLock`
6. `Java` 并发基础之`ReentrantReadLock`
程序员三木
47 0
游客cumdsexolybe4
|
Java
关于java中创建多线程的两种基本方式
关于java中创建多线程的两种基本方式
游客cumdsexolybe4
86 0

计算巢

热门文章

最新文章

  • 1
    3分钟部署 我的世界（Minecraft） 联机服务
  • 2
    快速部署 RAGFlow 社区版
  • 3
    产品动态丨阿里云计算巢月刊-2024年第10期
  • 4
    Java“Broken Pipe”解决
  • 5
    Docker Hub 镜像拉取超时：1Panel面板中应用安装失败的临时解决方案
  • 6
    Spring Boot 3 + JWT + Security 联手打造安全帝国：一篇文章让你掌握未来！
  • 7
    解决http下navigator.clipboard为undefined问题
  • 8
    使用Ollama和Open WebUI管理本地开源大模型
  • 9
    《触手可及，函数计算玩转 AI 大模型》解决方案评测
  • 10
    解决SpringBoot中@RequestBody不能和Multipart同时传递的问题
  • 1
    服务器数据恢复—raid5阵列+vxfs文件系统数据恢复案例
    8
  • 2
    在C语言中指针数组和数组指针在动态内存分配中的应用
    10
  • 3
    String 属于基础的数据类型吗
    13
  • 4
    Python开发淘宝详情API的深入探索
    13
  • 5
    在Arduino中使用数学库
    10
  • 6
    Nextcloud一键部署：快速搭建如企业钉钉或飞书的团队协作平台
    22
  • 7
    Java 多线程并发控制：深入理解与实战应用
    20
  • 8
    服务器数据恢复—逻辑卷管理（LVM）数据恢复案例
    10
  • 9
    阿里云帮你一键部署财务操作系统Maybe
    16
  • 10
    JDK 和 JRE 有什么区别
    12

    • 相关课程

    更多
  • Java 虚拟机原理
  • Java高级开发
  • Java面试疑难点解析 - Java Web开发
  • Java高级编程
  • Java零基础入门
  • Java面试疑难点解析 - 系统架构及项目设计

    • 相关电子书

    更多
  • Java高级特性入门（二）
  • Java 8 简明教程
  • Java8简明教程

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
    • 下一篇
    阿里云OSS设置跨域访问