将线程与信号量同步：在 Java 中练习并发 - LeetCode 问题“交替打印 FooBar”

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《将线程与信号量同步：在 Java 中练习并发 - LeetCode 问题“交替打印 FooBar”》，文章讲解的知识点主要包括，如果你对文章方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

并发简介
在软件开发中，并发允许多个进程或线程同时执行，通常会导致更快的执行时间和更有效地利用资源。然而，有效的并发管理对于避免竞争条件、死锁和不一致状态等问题至关重要。这就是信号量等同步机制必不可少的地方。

理解信号量
信号量是一种同步工具，用于控制并发系统中多个线程对公共资源的访问。它的作用就像一个计数器，调节有多少线程可以同时访问代码的特定部分。信号量操作是：

• 获取：如果信号量的计数器大于零，则减少该计数器，从而允许线程继续进行。如果为零，则线程将被阻塞，直到另一个线程释放信号量。
• 释放：增加信号量的计数器，表明线程已完成使用资源，允许其他等待线程继续。

信号量对于管理任务之间的依赖关系或确保程序的某些部分按特定顺序运行特别有用。

问题描述

class foobar {
  public void foo() {
    for (int i = 0; i < n; i++) {
      print("foo");
    }
  }

  public void bar() {
    for (int i = 0; i < n; i++) {
      print("bar");
    }
  }
}

我们有一个 foobar 类，它有两个方法：foo() 和 bar()。这些方法旨在分别打印“foo”和“bar”。挑战在于修改该类，以便当这些方法由两个不同的线程执行时，输出始终重复读取“foobar”n 次。无论调度程序的线程执行顺序如何，都必须实现这一点。

此问题源自 leetcode，具体来自问题 1115，“print foobar alternately”。

解决方法
为了确保正确的执行顺序（“foo”后跟“bar”），我们可以使用信号量来协调线程。以下是我们如何使用信号量修改现有的 foobar 类来实现所需的行为：

1. 引入两个信号量：一个信号量（semfoo）将控制foo()的执行，另一个信号量（sembar）将控制bar()。
2. 初始化信号量：semfoo 使用许可（count = 1）进行初始化，允许 foo() 首先执行。 sembar 在没有许可的情况下初始化（count = 0），阻止 bar() 执行，直到 foo() 完成。
3. 修改方法：每个方法在继续之前必须获取其信号量，并在执行其任务后释放另一个信号量。

这是 foobar 类的修改版本：

class foobar {
    private int n;
    private semaphore semfoo = new semaphore(1); // initially, allow foo() to proceed
    private semaphore sembar = new semaphore(0); // initially, prevent bar() from proceeding

    public foobar(int n) {
        this.n = n;
    }

    public void foo(runnable printfoo) throws interruptedexception {
        for (int i = 0; i < n; i++) {
            semfoo.acquire(); // wait until it's allowed to proceed
            printfoo.run();   // this will print "foo"
            sembar.release(); // allow bar() to proceed
        }
    }

    public void bar(runnable printbar) throws interruptedexception {
        for (int i = 0; i < n; i++) {
            sembar.acquire(); // wait until it's allowed to proceed
            printbar.run();   // this will print "bar"
            semfoo.release(); // allow foo() to proceed again
        }
    }
}

运行代码
为了演示此解决方案，我们可以创建 foobar 的实例并启动两个线程，每个线程负责其中一种方法：

public class Main {
    public static void main(String[] args) {
        FooBar fooBar = new FooBar(2); // Example for n = 2

        Thread threadA = new Thread(() -> {
            try {
                fooBar.foo(() -> System.out.print("foo"));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread threadB = new Thread(() -> {
            try {
                fooBar.bar(() -> System.out.print("bar"));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        threadA.start();
        threadB.start();
    }
}

此设置可确保 n = 2 时控制台上的输出为“foobarfoobar”，展示了信号量在控制 java 应用程序中线程执行顺序方面的强大功能。

理论要掌握，实操不能落！以上关于《将线程与信号量同步：在 Java 中练习并发 - LeetCode 问题“交替打印 FooBar”》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！