Java编程线程间通信与信号量代码示例

下面我将为您详细讲解“Java编程线程间通信与信号量代码示例”的攻略。

1. 什么是线程间通信和信号量？

在多线程编程中，线程间通信和信号量都是非常重要的概念。线程间通信是指多个线程之间共享同一块数据，需要明确地进行协作才能保证数据的正确性和完整性。而信号量则是用来控制并发访问的一种方式，通过对资源的访问进行限制，保证多个线程能够有序、安全地访问共享的资源。

2. 线程间通信的Demo示例

下面我们来看一个简单的线程间通信的示例代码：

public class ThreadDemo {

    public static void main(String[] args) {

        final MyQueue myQueue = new MyQueue();

        new Thread(() -> {
            myQueue.put("AA");
            myQueue.put("BB");
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(myQueue.take());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(myQueue.take());
        }).start();
    }

    static class MyQueue {

        private String data;

        public synchronized void put(String data) {
            while (this.data != null) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.data = data;
            System.out.println(Thread.currentThread().getName() + " put " + data);
            this.notifyAll();
        }

        public synchronized String take() {
            while (this.data == null) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            String data = this.data;
            this.data = null;
            System.out.println(Thread.currentThread().getName() + " take " + data);
            this.notifyAll();
            return data;
        }
    }

}

在本示例中，我们定义了一个MyQueue类来表示一个简单的队列，其中有两个方法：put()和take()，用于往队列中放入元素和取出元素。在put()方法和take()方法中，我们都使用了synchronized关键字来保证线程安全，同时使用了wait()和notifyAll()来进行线程间通信，确保线程间协作时值的正确性。

3. 信号量的Demo示例

下面我们再来看一个简单的信号量示例代码：

public class SemaphoreDemo {

    private static final int THREAD_COUNT = 30;

    private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);

    private static Semaphore semaphore = new Semaphore(10);

    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            threadPool.execute(new Runnable() {

                @Override
                public void run() {
                    try {
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName() + "获得许可证");
                        Thread.sleep(1000);
                        semaphore.release();
                        System.out.println(Thread.currentThread().getName() + "释放许可证");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        threadPool.shutdown();
    }

}

在本示例中，我们使用了Java中的Semaphore类来表示一个信号量，Semaphore类的构造方法需要指定信号量的初始值，这个值就是控制着并发线程数的关键。在每个线程中，我们首先需要使用acquire()方法获取许可证，随后执行需要进行同步的操作，然后再使用release()方法释放许可证。Semaphore会确保在获取到许可证的线程在操作期间独占资源，其他线程只有在获取到许可证后才能继续执行。

希望以上对您有帮助。