java信号量控制线程打印顺序的示例分享

Java信号量是一种同步原语，用于控制线程并发访问资源的数量。Java信号量的主要作用是保护临界区，以确保在任何时刻只有特定数量的线程可以访问该区域。在这里，我们将分享一个Java信号量控制线程打印顺序的示例，该示例演示如何使用Java信号量来协调多个线程以按特定顺序打印。

1. 示例一

在这个示例中，我们将创建两个线程，一个线程负责打印奇数，另一个线程负责打印偶数。我们将借助Java信号量来保证它们按照正确的顺序打印。下面是示例代码：

import java.util.concurrent.Semaphore;

public class PrintNumbers {
    private static final Semaphore semaphore = new Semaphore(1);
    private static int counter = 1;
    private static final Object lock = new Object();

    public static void main(String[] args) {

        Thread even = new Thread(() -> {
            while (counter <= 10) {
                try {
                    semaphore.acquire();
                    if (counter % 2 == 0) {
                        System.out.println(counter);
                        counter++;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }
        });

        Thread odd = new Thread(() -> {
            while (counter <= 10) {
                try {
                    semaphore.acquire();
                    if (counter % 2 != 0) {
                        System.out.println(counter);
                        counter++;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }
        });

        odd.start();
        even.start();
    }
}

在这个示例中，我们使用了两个线程，一个线程打印奇数，另一个线程打印偶数。我们使用Java信号量来确保它们交替打印。我们创建一个Semaphore对象，其构造函数中的参数是指定信号量允许的最大许可证数。在我们的示例中，我们将许可证数设置为1，这将确保每个线程以不同的顺序打印。

2. 示例二

在这个示例中，我们将演示如何使用无锁算法来实现Java信号量。我们将创建三个线程，其中一个线程将原子性地递增计数器，另外两个线程将轮流消耗信号量。下面是示例代码：

import java.util.concurrent.atomic.AtomicInteger;

public class SemaphoreExample2 {
    private static final AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            try {
                while (true) {
                    counter.incrementAndGet();
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                while (true) {
                    while (counter.get() >= 10) {
                        Thread.sleep(10);
                    }
                    counter.decrementAndGet();
                    System.out.println("Thread 2 acquired the semaphore.");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                while (true) {
                    while (counter.get() < 10) {
                        Thread.sleep(10);
                    }
                    counter.decrementAndGet();
                    System.out.println("Thread 3 acquired the semaphore.");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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

在这个示例中，我们使用了无锁算法来实现Java信号量。我们创建了一个AtomicInteger对象，其初始值为0，这将用于记录计数器的状态。我们同时创建了三个线程，其中一个线程负责递增计数器，另外两个线程将轮流消耗信号量。在线程2和线程3中，我们使用while循环来等待特定的条件满足，然后再使用counter.decrementAndGet()来递减计数器，这将意味着这个线程获取了信号量。在最后，这些线程将轮流打印“Thread 2 acquired the semaphore.”和“Thread 3 acquired the semaphore.”。

总之，这两个示例展示了如何使用Java信号量来协调多个线程并按顺序打印。第一个示例演示了如何使用Semaphore对象来交替打印奇数和偶数，第二个示例演示了无锁算法如何实现信号量。