使用Java中的wait方法

1. 简介

当多个线程需要协同工作时，我们需要使用Java中的wait()方法来实现线程之间的同步。该方法会使线程暂停执行并释放占用的锁，直到其他线程调用notify()或notifyAll()方法来通知它恢复执行。

2. wait()方法的使用

1. wait()方法的语法

    public final native void wait(long timeout) throws InterruptedException; 
    public final void wait(long timeout, int nanos) throws InterruptedException;
    public final void wait() throws InterruptedException;

wait()方法有三个重载形式：

• wait(long timeout)：使当前线程等待指定的毫秒数，或直到被通知或中断。
• wait(long timeout, int nanos)：与wait(long timeout)相似，但增加了纳秒级别的精度。
• wait()：使当前线程一直等待，直到被通知或中断。

2. wait()方法的原理

当线程调用wait()方法时，它会释放掉占有的锁，并让自己进入等待状态，直到其他线程调用了notify()或notifyAll()方法来通知它。

调用wait()方法的线程必须拥有该对象的锁。如果没有，则会抛出IllegalMonitorStateException异常。

一旦线程被通知，它会重新尝试获取锁，并继续执行。

3. wait()方法的应用场景

wait()方法通常用于实现线程之间的同步。下面是一些常见的wait()方法的应用场景：

• 生产者和消费者模式：使用wait()和notify()方法来协调生产者和消费者线程的工作。当队列为空时，消费者线程会调用wait()方法等待生产者放入数据；而当队列已满时，生产者线程会调用wait()方法等待消费者取走数据。
• 多线程协作：当多个线程需要互相协作时，可以使用wait()和notify()方法来实现线程之间的通信。

3. 示例代码

1. 生产者与消费者

class Producer extends Thread {
    Queue queue;

    Producer(Queue
    queue) {
        this.queue = queue;
    }

    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.size() >= 10) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("生产者生产数据: " + queue.size());
                queue.offer(1);
                queue.notifyAll();
            }
        }
    }
}

class Consumer extends Thread {
    Queue
     queue;

    Consumer(Queue
      queue) {
        this.queue = queue;
    }

    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.isEmpty()) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("消费者消费数据: " + queue.size());
                queue.poll();
                queue.notifyAll();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Queue
       queue = new LinkedList<>();
        Thread producer = new Producer(queue);
        Thread consumer = new Consumer(queue);
        producer.start();
        consumer.start();
    }
}

      
     
    
   
  

2. 多线程协作

class Worker extends Thread {
    private int id;
    private Object prev;
    private Object cur;

    Worker(int id, Object prev, Object cur) {
        this.id = id;
        this.prev = prev;
        this.cur = cur;
    }

    public void run() {
        while (true) {
            synchronized (prev) {
                synchronized (cur) {
                    System.out.println("Worker " + id + " is working.");
                    cur.notifyAll();
                }
                try {
                    prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class Main {
    private static final int n = 5;

    public static void main(String[] args) {
        Object[] objects = new Object[n];
        for (int i = 0; i < n; i++) {
            objects[i] = new Object();
        }
        Thread[] threads = new Thread[n];
        for (int i = 0; i < n - 1; i++) {
            threads[i] = new Worker(i, objects[i], objects[i + 1]);
        }
        threads[n - 1] = new Worker(n - 1, objects[n - 1], objects[0]);
        for (Thread t : threads) {
            t.start();
        }
    }
}

4. 总结

本文介绍了Java中的wait()方法，包括其语法、原理和应用场景。我们通过两个示例代码来演示了wait()方法的应用，一个是生产者和消费者模式，一个是多线程协作场景。wait()方法是实现线程之间同步通信的重要工具，我们在实际开发中需要充分理解其原理和应用场景，并适当运用它来提高应用程序的性能和稳定性。