线程同步与线程协作详解

于 2024-10-01 14:09:00 发布
阅读量324 收藏 7
点赞数 8
分类专栏： Java 学习 文章标签： java spring 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lssffy/article/details/142620576
版权
学习 同时被 2 个专栏收录
234 篇文章 8 订阅
订阅专栏
Java
127 篇文章 2 订阅
订阅专栏

引言

在现代的多线程编程中，线程同步和线程协作是两个至关重要的概念。线程同步确保多个线程能够安全地访问共享资源，而线程协作则涉及多个线程之间如何相互配合，共同完成复杂任务。理解并正确使用这两者，是保证并发程序高效且安全运行的关键。

本文将深入探讨线程同步和线程协作的原理，解释它们的区别，并通过图文和代码实例展示如何在 Java 中实现线程同步和线程协作。

第一部分：线程同步的概念

1.1 什么是线程同步？

线程同步是指多个线程在访问共享资源时，保证数据的完整性和一致性。由于多个线程可能同时访问或修改共享的内存数据（如变量、对象、文件等），线程同步的目标是防止数据竞争、保持共享资源的一致性。

例如，如果两个线程同时访问一个共享变量并进行修改，可能会导致数据不一致的问题。通过同步机制，程序可以确保只有一个线程在某一时刻能够访问共享资源。

1.2 线程同步的常见问题

  1. 数据竞争：当多个线程试图同时修改同一个数据时，可能会发生数据竞争，导致不可预测的行为。

  2. 死锁：多个线程互相等待彼此释放资源，导致程序无法继续执行。

  3. 饥饿：某些线程因为无法获取所需的资源而长期得不到执行。

1.3 为什么需要线程同步？

在并发环境中，如果不进行适当的同步，可能会导致以下问题：

  1. 数据不一致：多个线程同时修改共享数据，可能导致数据不一致。

  2. 非原子性操作：某些操作并不是原子性的，即使看似只有一个语句，也可能被多个线程同时执行，造成错误的结果。

  3. 可见性问题：由于 CPU 缓存和多核处理器的存在，某个线程对共享变量的修改，其他线程可能无法立即看到。

第二部分：Java 中的线程同步机制

2.1 synchronized 关键字

synchronized 是 Java 中用于实现线程同步的最基础的方式。它可以用于方法或代码块，确保同一时间只有一个线程可以进入 synchronized 方法或代码块。

2.1.1 使用 synchronized 修饰方法
public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

在这个例子中，increment() 和 getCount() 方法被 synchronized 修饰，确保同一时间只有一个线程能够访问这些方法，避免多个线程同时修改 count 导致数据不一致。

2.1.2 使用 synchronized 修饰代码块

有时我们不需要对整个方法进行同步，而只需要对某一段代码进行同步，此时可以使用 synchronized 代码块。

public class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

使用 synchronized 代码块时，我们可以自定义锁对象（如上例中的 lock），更加灵活地控制同步范围。

2.2 ReentrantLock

除了 synchronized 之外，Java 的并发包 (java.util.concurrent.locks) 提供了更高级的锁机制，ReentrantLock 是其中最常用的锁之一。

2.2.1 ReentrantLock 使用示例
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

在这个例子中，ReentrantLock 提供了手动控制锁的方式，必须在获取锁后记得显式释放锁。相比 synchronized，ReentrantLock 提供了更灵活的功能，如公平锁、非阻塞尝试获取锁等。

2.2.2 ReentrantLock 的优势
  • 手动控制锁的获取和释放：通过 lock() 和 unlock()，开发者可以精确控制锁的使用。
  • 支持公平锁：可以配置为公平锁，确保线程按照请求锁的顺序获取锁。
  • 可中断锁获取：ReentrantLock 支持在锁获取过程中被中断，而 synchronized 不支持这一功能。

2.3 读写锁 (ReadWriteLock)

Java 还提供了读写锁机制，允许多个线程同时读取共享资源，但只允许一个线程写入。这种机制非常适合读多写少的场景。

2.3.1 读写锁示例
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Data {
    private int value = 0;
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void write(int newValue) {
        lock.writeLock().lock();
        try {
            value = newValue;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int read() {
        lock.readLock().lock();
        try {
            return value;
        } finally {
            lock.readLock().unlock();
        }
    }
}

在这个例子中，write() 方法使用写锁，read() 方法使用读锁。多个线程可以同时调用 read() 方法，但只有一个线程可以调用 write() 方法。

第三部分：线程协作

3.1 什么是线程协作？

线程协作是指多个线程之间通过某种机制相互配合，共同完成任务。与线程同步不同，线程协作更多关注的是如何通过线程之间的通信和协调，让不同线程的任务有序执行。

Java 提供了多种线程协作机制，常见的有 wait()/notify() 机制、CountDownLatch、CyclicBarrier、Semaphore 等。

3.2 wait()/notify()/notifyAll()

wait() 和 notify() 是 Java 中最基础的线程协作机制。它们用于一个线程等待另一个线程完成某项任务后再继续执行。

3.2.1 wait()/notify() 示例
public class WaitNotifyExample {
    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1: Waiting for notification...");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Received notification, proceeding...");
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2: Sending notification...");
                lock.notify();
                System.out.println("Thread 2: Notification sent.");
            }
        });

        thread1.start();
        Thread.sleep(1000);  // 确保 Thread 1 先进入等待状态
        thread2.start();
    }
}

在这个例子中，Thread 1 进入等待状态，直到 Thread 2 调用了 lock.notify()，唤醒 Thread 1 继续执行。

3.2.2 notifyAll() 的使用

notify() 只能唤醒一个等待线程，而 notifyAll() 可以唤醒所有等待的线程。

synchronized (lock) {
    lock.notifyAll();  // 唤醒所有等待的线程
}

3.3 CountDownLatch

CountDownLatch 是一种同步工具类，它允许一个或多个线程等待，直到其他线程完成某些操作。

3.3.1 CountDownLatch 示例
import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    private static final int THREAD_COUNT = 3;

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);

        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " is running.");
                latch.countDown();  // 每个线程执行完毕后调用 countDown()
            }).start();
        }

        latch.await();  // 等待所有线程完成
        System.out.println("All threads have finished.");
    }
}

在这个例子中，主线程将等待所有

子线程执行完毕后再继续执行。每个子线程在完成任务后都会调用 countDown()，当计数器达到 0 时，主线程会被唤醒。

3.4 CyclicBarrier

CyclicBarrier 是另一种线程协作工具，它允许一组线程相互等待，直到所有线程都到达一个共同的屏障点。CyclicBarrier 可以被重复使用，因此特别适合迭代的任务。

3.4.1 CyclicBarrier 示例
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {

    private static final int THREAD_COUNT = 3;

    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT, () -> {
            System.out.println("All threads have reached the barrier, proceeding...");
        });

        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " is waiting at the barrier.");
                try {
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " has crossed the barrier.");
            }).start();
        }
    }
}

在这个例子中，所有线程会等待在屏障处，直到所有线程都到达屏障后再继续执行。

3.5 Semaphore

Semaphore 是用于控制线程访问共享资源的计数信号量。它允许一定数量的线程同时访问某个资源。

3.5.1 Semaphore 示例
import java.util.concurrent.Semaphore;

public class SemaphoreExample {

    private static final Semaphore semaphore = new Semaphore(2);

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + " acquired a permit.");
                    Thread.sleep(2000);  // 模拟任务执行
                    System.out.println(Thread.currentThread().getName() + " released a permit.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }).start();
        }
    }
}

在这个例子中，Semaphore 控制最多允许两个线程同时访问共享资源。

第四部分：线程同步与线程协作的常见问题

4.1 死锁问题

死锁是指两个或多个线程互相等待对方释放资源，导致程序永远无法继续执行。

4.1.1 死锁示例
public class DeadlockExample {

    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock1...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Waiting for lock2...");
                synchronized (lock2) {
                    System.out.println("Thread 1: Acquired lock2!");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2: Holding lock2...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: Waiting for lock1...");
                synchronized (lock1) {
                    System.out.println("Thread 2: Acquired lock1!");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

在这个示例中，Thread 1 持有 lock1 并等待 lock2，同时 Thread 2 持有 lock2 并等待 lock1，造成了死锁。

4.1.2 死锁解决方法

解决死锁的常见方法是使用锁的顺序化，确保所有线程按照相同的顺序获取锁，避免循环等待。

第五部分：线程同步与协作的最佳实践

5.1 使用较高层次的并发工具

尽量使用 Java 并发包中的工具类（如 CountDownLatch、Semaphore、CyclicBarrier 等）来实现线程协作，而不是使用低层次的 wait() 和 notify()。

5.2 减少锁的粒度

尽量缩小锁的粒度，即只锁住真正需要同步的代码块，避免不必要的性能开销。

5.3 避免嵌套锁

尽量避免使用嵌套锁，减少死锁发生的可能性。如果必须使用多个锁，确保所有线程获取锁的顺序一致。

5.4 使用线程池管理线程

在实际开发中，推荐使用线程池管理线程的创建和销毁，避免频繁创建和销毁线程带来的性能问题。

第六部分：总结

线程同步和线程协作是并发编程中的两个重要概念。线程同步主要关注如何保证多个线程在访问共享资源时保持数据的一致性，而线程协作则是多个线程之间的相互配合与协调。通过合理使用 synchronized、ReentrantLock、CountDownLatch、CyclicBarrier 等工具类，开发者可以编写出高效且安全的多线程应用程序。

在实际开发中，理解并应用线程同步和协作的机制，避免死锁、数据竞争等问题，是确保多线程程序稳定运行的关键。

CopyLower
关注
专栏目录
多线程之线程同步与协助
qq_60501861的博客
08-31 192
并发： 同一个对象被多个线程同时操作 现实生活中，我们会遇到”同一个资源，多个人都想使用”的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是，排队一个个来。 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象.这时候我们就需要线程同步.线程同步其实就是一种等待机制，多个需要同时访问！此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。 形成线程安全的条件：队列+锁锁机制【synchronized】 由于同一进程的多个线程共享同一块存储空间，
多线程同步，通信知识详解
心比天高，仗剑走天涯，保持热爱，奔赴向梦想！
03-08 1671
多线程同步，通信知识详解线程同步及同步块同步块lock锁程通信问题生产者和消费者模式（这个模式并不是23种设计模式中的）管程法信号灯法线程池 线程同步及同步块 结合上篇发布的文章，线程同步就算是讲完了。因为篇幅过长，所以这块被迫分成了两块 同步方法 由于private关键字来保证数据对象只能被方法所访问。所以我们只需要针对方法提出一套机制 synchronized关键字，包括synchronize方法和synchronized块 public synchronized void method(int a
『Java』线程与同步
七秒钟的记忆
07-09 186
Java 线程与同步的简单介绍，重点理解线程与同步基本概念和同步的解决方法。
C#多线程详解
世界既不黑也不白，而是一道精致的灰。
08-11 3164
上下文切换（Context Switching）是多线程环境中的一种操作，指的是在一个 CPU 核心上切换正在执行的线程，从当前线程的执行上下文（包括寄存器状态、程序计数器等）切换到另一个线程的执行上下文, 线程的切换需要额外的开销，因此在某些情况下，过多的线程可能会导致性能下降。因此，在设计多线程应用程序时，需要考虑如何减少上下文切换的发生，以提高程序的执行效率。是用于实现线程同步的一种机制，用于保护共享资源，避免竞态条件。上下文切换开销指的是从一个线程切换到另一个线程的过程中所涉及的时间和资源开销。
多线程详解第5讲：线程协作
林深不见鹿 的博客
04-23 5819
线程协作 这里写目录标题线程协作1、线程通信2、线程通信分析3、解决方式14、解决方式25、使用线程池 1、线程通信 应用场景 : 生产者和消费者问题 假设仓库中只能存放一件产品 , 生产者将生产出来的产品放入仓库 , 消费者将仓库中产品取走消费 如果仓库中没有产品 , 则生产者将产品放入仓库 , 否则停止生产并等待 , 直到仓库中的产品被消费者取走为止 如果仓库中放有产品 , 则消费者可以将产品取走消费 , 否则停止消费并等待 , 直到仓库中再次放入产品为止 2、线程通信分析 这是一个线程同步问题
Java中进程与线程详解
qq_45295130的博客
08-02 290
目录 一、了解进程与线程 进程 线程 二、进程与线程的区别 三、进程与线程的关系 四、进程间通信方式 五、进程与线程适用情景 一、了解进程与线程 进程 指在系统中正在运行的一个应用程序，程序一旦运行就是一个进程。进程是程序执行时的一个实例，即它是程序已经执行到何种程度的数据结构的汇集。从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。 线程 线程是进程中执行运算的最小单位，是进程中的一个实体，是被系统独立调度和分派的基本单...
1、【java线程及线程池系列】java线程及线程池概念详解
热门推荐
alanchanchn的专栏
06-12 4万+
缓冲队列长度的设置，按照一般的理解应该设置成maximumPoolSize的5倍，因为单个线程在不切换cpu的情况下是单个cpu运算一个线程，corePoolSize设置成和cpu一样的数量，maximumPoolSize设置成cpu的2倍，避免cpu处于空闲状态则直接加入一旦cpu空闲理解执行的线程数量，同时由于cpu的速度较快以及有请求执行的线程加入缓冲队列中减少cpu等待时间，故将缓冲队列设置大一些。线程池存在的目的在于提前创建好需要的线程，减少临时创建线程带来的资源消耗。
单线程，多线程，异步，同步详解
qq_23018459的博客
08-26 758
在这7分钟中，原来的柜员一直与我互动，我收到现钞后，由递交给我现钞的那位柜员坐下继续负责与我互动，其余柜员去后台干别的去了。下面就是一个使用异步实现读取一个超大文件的一个代码，主程序Main()的执行并没有因ReadHeavy()函数的执行而冻结，“Read finished” 的打印在子函数ReadHeavy()中，子函数被调用的代码是在 “Read file started” 被打印之前，但其真正被执行则在其之后，且在编写这段程序的程序员手里，这段代码仅有一个线程，因此这是一个协程异步程序。
Qt线程详解
lzw19971106的博客
04-28 3336
线程与进程有什么区别呢？ 举个简单的例子，当你在LOL的时候，在相同的桌面上可能有一个播放器正在播放你最喜欢的歌曲。这是一个两个进程并行工作的例子：一个进程运行LOL程序;另一个进程运行一个媒体播放器。这种情况最适合用多任务这个词来描述。进一步观察播放器，你会发现在这个进程内，又存在并行的工作。当播放器向音频驱动发送音乐数据的时候，用户界面上与之相关的歌词信息不断地进行更新。这就是单个进程内的并行...
详解python多线程之间的同步(一)
09-19
在Python编程中，多线程同步是解决并发执行过程中数据安全和资源争夺问题的关键技术。本文将深入探讨Python中实现线程同步的几种方法，包括Event、Lock以及更高级的同步原语，如Mutex和Semaphore。 首先，Event对象...
Java多线程同步器代码详解
08-28
Java多线程同步器在并发编程中扮演着至关重要的角色，它们帮助开发者管理线程间的协作，确保资源的正确访问和程序的顺序执行。本文将深入解析四种主要的同步器：CountDownLatch、Semaphore、Barrier和Exchanger，并...
详解Java编程中线程同步以及定时启动线程的方法
09-02
下面是一个使用wait()和notify()实现线程协作的例子，展示了如何模拟单个线程对多个线程的唤醒过程： ```java class Game { // ... public void prepare(Athlete athlete) throws InterruptedException { System...
详解Linux多线程使用信号量同步
09-15
线程间的信号量与进程间通信中的信号量相似，但这里的信号量主要应用于线程同步。二进制信号量是最常见的类型，其值只能为0或1，通常用于实现互斥锁，保证同一时刻只有一个线程能访问特定资源。 在Linux中，信号量...
多线程与线程池技术详解
06-12
4. **同步与互斥**：在多线程环境中，为了避免数据不一致，需要使用synchronized关键字进行同步控制，或者使用Lock接口及其实现类如ReentrantLock实现更灵活的锁定机制。 5. **线程通信**：wait()、notify()和...
工厂模式的介绍及实现
户伟伟的博客
09-25 148
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 515
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
最新发布
Lxn2zh的博客
09-30 373
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 520
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CopyLower

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值