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

简介: 《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 接口及其实现类,如 ArrayBlockingQueueLinkedBlockingQueue 等,用于方便地实现生产者 - 消费者模式等线程间通信场景。例如:
    ```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. 资源竞争
  • 资源竞争是指多个线程同时访问共享资源时可能导致数据不一致或错误的情况。除了使用同步机制(如 synchronizedReentrantLock)来保护共享资源外,还可以采用原子类来处理一些简单的原子操作。例如,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 多线程并发编程中得心应手,构建出高效、稳定的多线程应用程序。

相关文章
|
11天前
|
存储 人工智能 弹性计算
阿里云弹性计算_加速计算专场精华概览 | 2024云栖大会回顾
2024年9月19-21日,2024云栖大会在杭州云栖小镇举行,阿里云智能集团资深技术专家、异构计算产品技术负责人王超等多位产品、技术专家,共同带来了题为《AI Infra的前沿技术与应用实践》的专场session。本次专场重点介绍了阿里云AI Infra 产品架构与技术能力,及用户如何使用阿里云灵骏产品进行AI大模型开发、训练和应用。围绕当下大模型训练和推理的技术难点,专家们分享了如何在阿里云上实现稳定、高效、经济的大模型训练,并通过多个客户案例展示了云上大模型训练的显著优势。
|
15天前
|
存储 人工智能 调度
阿里云吴结生:高性能计算持续创新,响应数据+AI时代的多元化负载需求
在数字化转型的大潮中,每家公司都在积极探索如何利用数据驱动业务增长,而AI技术的快速发展更是加速了这一进程。
|
6天前
|
并行计算 前端开发 物联网
全网首发!真·从0到1!万字长文带你入门Qwen2.5-Coder——介绍、体验、本地部署及简单微调
2024年11月12日,阿里云通义大模型团队正式开源通义千问代码模型全系列,包括6款Qwen2.5-Coder模型,每个规模包含Base和Instruct两个版本。其中32B尺寸的旗舰代码模型在多项基准评测中取得开源最佳成绩,成为全球最强开源代码模型,多项关键能力超越GPT-4o。Qwen2.5-Coder具备强大、多样和实用等优点,通过持续训练,结合源代码、文本代码混合数据及合成数据,显著提升了代码生成、推理和修复等核心任务的性能。此外,该模型还支持多种编程语言,并在人类偏好对齐方面表现出色。本文为周周的奇妙编程原创,阿里云社区首发,未经同意不得转载。
|
11天前
|
人工智能 运维 双11
2024阿里云双十一云资源购买指南(纯客观,无广)
2024年双十一,阿里云推出多项重磅优惠,特别针对新迁入云的企业和初创公司提供丰厚补贴。其中,36元一年的轻量应用服务器、1.95元/小时的16核60GB A10卡以及1元购域名等产品尤为值得关注。这些产品不仅价格亲民,还提供了丰富的功能和服务,非常适合个人开发者、学生及中小企业快速上手和部署应用。
|
7天前
|
人工智能 自然语言处理 前端开发
用通义灵码,从 0 开始打造一个完整APP,无需编程经验就可以完成
通义灵码携手科技博主@玺哥超carry 打造全网第一个完整的、面向普通人的自然语言编程教程。完全使用 AI,再配合简单易懂的方法,只要你会打字,就能真正做出一个完整的应用。本教程完全免费,而且为大家准备了 100 个降噪蓝牙耳机,送给前 100 个完成的粉丝。获奖的方式非常简单,只要你跟着教程完成第一课的内容就能获得。
|
1天前
|
云安全 存储 弹性计算
|
22天前
|
自然语言处理 数据可视化 前端开发
从数据提取到管理:合合信息的智能文档处理全方位解析【合合信息智能文档处理百宝箱】
合合信息的智能文档处理“百宝箱”涵盖文档解析、向量化模型、测评工具等,解决了复杂文档解析、大模型问答幻觉、文档解析效果评估、知识库搭建、多语言文档翻译等问题。通过可视化解析工具 TextIn ParseX、向量化模型 acge-embedding 和文档解析测评工具 markdown_tester,百宝箱提升了文档处理的效率和精确度,适用于多种文档格式和语言环境,助力企业实现高效的信息管理和业务支持。
3966 5
从数据提取到管理:合合信息的智能文档处理全方位解析【合合信息智能文档处理百宝箱】
|
11天前
|
算法 安全 网络安全
阿里云SSL证书双11精选,WoSign SSL国产证书优惠
2024阿里云11.11金秋云创季活动火热进行中,活动月期间(2024年11月01日至11月30日)通过折扣、叠加优惠券等多种方式,阿里云WoSign SSL证书实现优惠价格新低,DV SSL证书220元/年起,助力中小企业轻松实现HTTPS加密,保障数据传输安全。
534 3
阿里云SSL证书双11精选,WoSign SSL国产证书优惠
|
10天前
|
数据采集 人工智能 API
Qwen2.5-Coder深夜开源炸场,Prompt编程的时代来了!
通义千问团队开源「强大」、「多样」、「实用」的 Qwen2.5-Coder 全系列,致力于持续推动 Open Code LLMs 的发展。
|
18天前
|
安全 数据建模 网络安全
2024阿里云双11,WoSign SSL证书优惠券使用攻略
2024阿里云“11.11金秋云创季”活动主会场,阿里云用户通过完成个人或企业实名认证,可以领取不同额度的满减优惠券,叠加折扣优惠。用户购买WoSign SSL证书,如何叠加才能更加优惠呢?
999 3