正文

Java线程暂停：掌握这5种高效暂停技术，告别阻塞烦恼

/0 浏览量
0730

在Java编程中，线程的暂停是一个常见的操作，它允许我们在需要的时候让线程停止执行，直到某个条件满足或者某个时间到达。正确地使用线程暂停技术可以避免不必要的资源浪费和阻塞，提高程序的效率。下面，我将详细介绍五种高效的Java线程暂停技术。

1. 使用Thread.sleep()

Thread.sleep(long millis)是Java中最常用的线程暂停方法。它会使当前线程暂停执行指定的毫秒数。这是一个简单的阻塞方法，适用于不需要在暂停期间进行任何操作的情况。

public class SleepExample {
    public static void main(String[] args) {
        try {
            System.out.println("线程开始休眠...");
            Thread.sleep(2000); // 暂停2秒
            System.out.println("线程休眠结束...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2. 使用Object.wait()

Object.wait()方法可以使当前线程等待，直到另一个线程调用该对象的notify()或notifyAll()方法。这种方法通常用于线程间的通信。

public class WaitExample {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread producer = new Thread(new Producer(lock));
        Thread consumer = new Thread(new Consumer(lock));
        producer.start();
        consumer.start();
    }
}

class Producer implements Runnable {
    private Object lock;

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

    @Override
    public void run() {
        synchronized (lock) {
            try {
                System.out.println("生产者开始生产...");
                lock.wait();
                System.out.println("生产者生产完成...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    private Object lock;

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

    @Override
    public void run() {
        synchronized (lock) {
            try {
                System.out.println("消费者开始消费...");
                lock.wait();
                System.out.println("消费者消费完成...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3. 使用Object.notify()

Object.notify()方法用于唤醒一个在此对象监视器上等待的单个线程。与wait()方法配合使用，可以实现线程间的通信。

public class NotifyExample {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread producer = new Thread(new Producer(lock));
        Thread consumer = new Thread(new Consumer(lock));
        producer.start();
        consumer.start();
    }
}

class Producer implements Runnable {
    private Object lock;

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

    @Override
    public void run() {
        synchronized (lock) {
            try {
                System.out.println("生产者开始生产...");
                lock.wait();
                System.out.println("生产者生产完成...");
                lock.notify();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    private Object lock;

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

    @Override
    public void run() {
        synchronized (lock) {
            try {
                System.out.println("消费者开始消费...");
                lock.wait();
                System.out.println("消费者消费完成...");
                lock.notify();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4. 使用Object.notifyAll()

Object.notifyAll()方法用于唤醒在此对象监视器上等待的所有线程。这通常用于需要唤醒所有等待线程的场景。

public class NotifyAllExample {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread producer = new Thread(new Producer(lock));
        Thread consumer = new Thread(new Consumer(lock));
        producer.start();
        consumer.start();
    }
}

class Producer implements Runnable {
    private Object lock;

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

    @Override
    public void run() {
        synchronized (lock) {
            try {
                System.out.println("生产者开始生产...");
                lock.wait();
                System.out.println("生产者生产完成...");
                lock.notifyAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    private Object lock;

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

    @Override
    public void run() {
        synchronized (lock) {
            try {
                System.out.println("消费者开始消费...");
                lock.wait();
                System.out.println("消费者消费完成...");
                lock.notifyAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5. 使用ReentrantLock

ReentrantLock是Java 5引入的一个更高级的锁机制，它提供了比传统的synchronized关键字更丰富的功能。ReentrantLock也支持线程的暂停和唤醒。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private Lock lock = new ReentrantLock();

    public void produce() {
        lock.lock();
        try {
            System.out.println("生产者开始生产...");
            // 暂停一段时间
            Thread.sleep(2000);
            System.out.println("生产者生产完成...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consume() {
        lock.lock();
        try {
            System.out.println("消费者开始消费...");
            // 暂停一段时间
            Thread.sleep(2000);
            System.out.println("消费者消费完成...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        Thread producer = new Thread(example::produce);
        Thread consumer = new Thread(example::consume);
        producer.start();
        consumer.start();
    }
}

通过以上五种方法，你可以根据实际需求选择合适的线程暂停技术。正确地使用这些技术，可以帮助你更好地控制线程的执行，提高程序的效率。

-- 展开阅读全文 --