java如何阻塞程序

在Java中，阻塞程序是一种常见的编程技术，通常用于控制程序的执行流程，等待某个条件满足或者某个操作完成。Java中阻塞程序的主要方式包括：等待输入输出操作完成、使用线程的sleep方法、使用线程的wait和notify方法、使用阻塞队列、使用Lock和Condition、使用Future和Callable。其中，使用线程的sleep方法是最基础和常用的一种阻塞程序的方式。

一、使用线程的SLEEP方法

线程的sleep方法可以使当前线程暂停指定的时间，这个时间可以精确到毫秒。调用sleep方法后，当前线程将进入阻塞状态，不会占用CPU资源，而是将CPU资源让给其他线程使用。当指定的时间到达后，线程将自动唤醒并恢复运行。

public class SleepExample {
    public static void main(String[] args) {
        System.out.println("Start");
        try {
            // 阻塞当前线程2秒
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("End");
    }
}

在上面的代码中，我们在主线程中调用了Thread.sleep(2000)，这将使主线程阻塞2秒。在这2秒内，主线程不会执行任何操作，也不会占用CPU资源。

二、使用线程的WAIT和NOTIFY方法

wait和notify是Java中的两个线程间通信的方法。调用对象的wait方法可以使当前线程进入等待状态，直到其他线程调用同一个对象的notify方法唤醒它。这种方式常用于多线程环境中，当一个线程需要等待其他线程完成某个操作时。

public class WaitNotifyExample {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1: Waiting");
                    lock.wait();
                    System.out.println("Thread 1: Resumed");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2: Notify");
                lock.notify();
            }
        });
        thread1.start();
        thread2.start();
    }
}

三、使用阻塞队列

Java的java.util.concurrent包提供了多种阻塞队列，如ArrayBlockingQueue、LinkedBlockingQueue等。阻塞队列在添加元素时，如果队列已满，那么线程将阻塞，直到队列有空位为止。同样，在移除元素时，如果队列已空，线程也将阻塞，直到队列有元素为止。

public class BlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(3);
        for (int i = 0; i < 4; i++) {
            // 如果队列已满，将阻塞线程
            queue.put(i);
            System.out.println("Added: " + i);
        }
    }
}

四、使用LOCK和CONDITION

Lock和Condition接口提供了一种更灵活的线程同步机制。通过调用Lock对象的lock方法，线程可以获取锁，如果锁被其他线程占用，那么当前线程将阻塞，直到锁被释放。Condition则提供了一种线程间的条件等待和唤醒机制。

public class LockConditionExample {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        Thread thread1 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Thread 1: Waiting");
                condition.await();
                System.out.println("Thread 1: Resumed");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });
        Thread thread2 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Thread 2: Notify");
                condition.signal();
            } finally {
                lock.unlock();
            }
        });
        thread1.start();
        thread2.start();
    }
}

五、使用FUTURE和CALLABLE

Future和Callable是Java中处理并发的另一种方式。Callable是一个带有返回值的Runnable，它的call方法将返回一个结果。Future则是一个可以获取Callable返回结果的对象。如果在调用Future的get方法时，Callable的结果还没有计算完，那么get方法将阻塞，直到结果计算完毕。

public class FutureCallableExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(() -> {
            Thread.sleep(2000);
            return 123;
        });
        System.out.println("Waiting for result");
        System.out.println("Result: " + future.get());
        executor.shutdown();
    }
}

通过以上几种方式，我们可以在Java中实现阻塞程序。在使用时，需要根据具体的场景和需求选择合适的方式。

java如何阻塞程序

相关问答FAQs：