Java中线程挂起的几种方式详解

在Java中，我们可以通过挂起线程来实现线程的暂停，以便于进行一些特殊的处理。下面将介绍Java中线程挂起的几种方式。

1. 使用Thread.sleep()

调用Thread.sleep()方法可以让当前线程休眠指定的时间（以毫秒为单位）。例如，以下代码将让当前线程休眠5秒钟：

try {
    Thread.sleep(5000); // 休眠5秒钟
} catch (InterruptedException e) {
    e.printStackTrace();
}

需要注意的是，Thread.sleep()方法可能会抛出InterruptedException异常，如果在休眠的过程中线程被中断了，就会抛出该异常。

2. 使用Thread.wait()

调用Thread.wait()方法可以让当前线程进入等待状态，直到其它线程调用了该对象的notify()或notifyAll()方法。例如，以下代码将让线程进入等待状态：

synchronized (lock) {
    try {
        lock.wait(); // 等待其它线程唤醒
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

这里的myLock是一个共享对象，这个线程会暂时释放对该对象的锁定，并进入等待状态，直到其它线程唤醒后才会继续执行。

3. 使用Thread.yield()

调用Thread.yield()方法可以让当前线程让出CPU执行时间，让其它线程有机会运行。例如，以下代码将线程让出CPU执行时间：

Thread.yield();// 让出CPU执行时间

需要注意的是，Thread.yield()方法并不是每次都有效的，当CPU本来就没有其它可以运行的线程时，这个方法可能会被忽略。

示例说明

以下是一个示例代码，通过使用Thread.sleep()方法来实现一个定时器功能。这个定时器会每隔1秒钟输出一次当前的时间。

public class TimerThread extends Thread {
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);// 休眠1秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(new Date());// 输出当前时间
        }
    }
}

另外一个示例则是使用Thread.wait()方法来实现生产者消费者模式。以下是一个简单的示例代码：

public class ProducerConsumerDemo {
    private static final int MAX = 10;// 缓冲区大小
    private static final List<Integer> buffer = new ArrayList<>(MAX);// 缓冲区

    public static void main(String[] args) {
        Object lock = new Object();
        new Producer(lock).start();// 启动生产者线程
        new Consumer(lock).start();// 启动消费者线程
    }

    static class Producer extends Thread {
        private final Object lock;

        public Producer(Object lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            while (true) {
                synchronized (lock) {
                    while (buffer.size() == MAX) {// 缓冲区满了，生产者线程等待
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    buffer.add(1);// 生产一个数据
                    System.out.println("Producer put: " + buffer.size() + " item(s)");// 输出缓冲区中数据的个数
                    lock.notify();// 唤醒其它等待在锁上的线程
                }
            }
        }
    }

    static class Consumer extends Thread {
        private final Object lock;

        public Consumer(Object lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            while (true) {
                synchronized (lock) {
                    while (buffer.isEmpty()) {// 缓冲区为空，消费者线程等待
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    buffer.remove(0);// 消费一个数据
                    System.out.println("Consumer get: " + buffer.size() + " item(s)");// 输出缓冲区中数据的个数
                    lock.notify();// 唤醒其它等待在锁上的线程
                }
            }
        }
    }
}

在这个示例中，生产者线程和消费者线程共享一个锁，并根据缓冲区的状态进行等待和唤醒操作，来保证生产和消费的正确性。