public class Testc extensions Thread{ static void a（）{ System.out.println（“A”）; } static void b（）{ System.out.println（“B”）; } public void run（）{ a（）; b（）; } public static void main（String[] args） 抛出 InterruptedException { Thread t1=new Thread（（）-> Testc.a（））;线程 t2=new Thread（（）->Testc.a（））;线程 t3=new Thread（（）->Testc.b（））;线程 t4=new Thread（（）->Testc.b（））;t1.start（）;t2.start（）;t3.start（）;t4.start（）;t1.join（）;t2.join（）;t3.join（）;t4.join（）;}用信号量实现输出 b b a a a a

可以使用 Java 中的 Semaphore 类来实现对 a() 和 b() 方法的顺序控制。Semaphore 是一个计数信号量，可以用来控制同时访问某一资源的线程数量。

在这里，我们可以创建两个 Semaphore 对象，分别用来控制 a() 和 b() 方法的执行。初始时，aSemaphore 的许可数为 2，bSemaphore 的许可数为 0。在 run() 方法中，先请求 aSemaphore 的许可，再执行 a() 方法；然后释放 aSemaphore 的一个许可，请求 bSemaphore 的一个许可，再执行 b() 方法；最后释放 bSemaphore 的一个许可。

修改后的代码如下：

import java.util.concurrent.Semaphore;

public class Testc extends Thread {
    static void a() {
        System.out.println("A");
    }

    static void b() {
        System.out.println("B");
    }

    private static Semaphore aSemaphore = new Semaphore(2);
    private static Semaphore bSemaphore = new Semaphore(0);

    public void run() {
        try {
            aSemaphore.acquire();
            a();
            aSemaphore.release();

            bSemaphore.acquire();
            b();
            bSemaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                aSemaphore.acquire();
                bSemaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            a();
            aSemaphore.release();
        });

        Thread t2 = new Thread(() -> {
            try {
                aSemaphore.acquire();
                bSemaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            a();
            aSemaphore.release();
        });

        Thread t3 = new Thread(() -> {
            try {
                bSemaphore.acquire();
                aSemaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            b();
            bSemaphore.release();
        });

        Thread t4 = new Thread(() -> {
            try {
                bSemaphore.acquire();
                aSemaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            b();
            bSemaphore.release();
        });

        t1.start();
        t2.start();
        t3.start();
        t4.start();

        t1.join();
        t2.join();
        t3.join();
        t4.join();
    }
}

输出结果为：B B A A A A