正文

Java中如何阻塞线程详解：掌握常见阻塞方法及实际应用案例

/0 浏览量
0403

在Java编程中，阻塞线程是一种常见的操作，它可以让线程暂停执行，直到某个条件满足或某个事件发生。掌握阻塞方法对于编写高效、响应迅速的程序至关重要。本文将详细介绍Java中常见的阻塞方法及其在实际应用中的案例。

一、常见阻塞方法

1. 使用sleep()方法

sleep()方法是Thread类提供的一个静态方法，它可以让当前线程暂停执行指定的时间（以毫秒为单位）。在暂停期间，线程不会释放它所持有的任何监视器锁。

public class SleepExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread starting...");
            try {
                Thread.sleep(2000); // 暂停2秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread resumed...");
        });
        thread.start();
    }
}

2. 使用wait()方法

wait()方法是Object类提供的一个实例方法，它可以使当前线程等待，直到其他线程调用该对象的notify()或notifyAll()方法。使用wait()方法时，线程会释放它所持有的所有监视器锁。

public class WaitExample {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread producer = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Producer producing...");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Producer notified...");
            }
        });

        Thread consumer = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Consumer consuming...");
                lock.notify();
            }
        });

        producer.start();
        consumer.start();
    }
}

3. 使用join()方法

join()方法是Thread类提供的一个实例方法，它可以使当前线程等待，直到指定的线程结束。在等待期间，当前线程会释放它所持有的所有监视器锁。

public class JoinExample {
    public static void main(String[] args) {
        Thread childThread = new Thread(() -> {
            System.out.println("Child thread is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Child thread finished.");
        });

        Thread parentThread = new Thread(() -> {
            System.out.println("Parent thread starting...");
            childThread.start();
            try {
                childThread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Parent thread finished.");
        });

        parentThread.start();
    }
}

4. 使用CountDownLatch类

CountDownLatch类可以用来协调多个线程的执行。它允许一个或多个线程等待其他线程完成操作。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(3);

        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 finished.");
            latch.countDown();
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 finished.");
            latch.countDown();
        });

        Thread thread3 = new Thread(() -> {
            System.out.println("Thread 3 is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 3 finished.");
            latch.countDown();
        });

        thread1.start();
        thread2.start();
        thread3.start();

        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("All threads finished.");
    }
}

5. 使用CyclicBarrier类

CyclicBarrier类可以用来协调多个线程，直到所有线程都到达某个点。一旦所有线程都到达这个点，它们会一起执行一个操作，然后继续执行。

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("Barrier action executed.");
        });

        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 reached the barrier.");
            try {
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 continued after the barrier.");
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 reached the barrier.");
            try {
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 continued after the barrier.");
        });

        Thread thread3 = new Thread(() -> {
            System.out.println("Thread 3 is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 3 reached the barrier.");
            try {
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 3 continued after the barrier.");
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

6. 使用Semaphore类

Semaphore类可以用来控制对共享资源的访问。它允许一定数量的线程访问资源，当达到最大数量时，其他线程会等待。

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2);

        Thread thread1 = new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println("Thread 1 acquired the semaphore.");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println("Thread 2 acquired the semaphore.");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        });

        thread1.start();
        thread2.start();
    }
}

二、实际应用案例

以下是一些在实际应用中使用阻塞方法的案例：

1. 多线程下载

在多线程下载中，可以使用CountDownLatch来协调多个下载线程的执行，确保所有线程都完成下载后再进行后续操作。

2. 生产者-消费者模式

在生产者-消费者模式中，可以使用Semaphore来控制对共享缓冲区的访问，确保生产者和消费者之间的同步。

3. 线程池

在线程池中，可以使用CyclicBarrier来协调线程池中的线程执行任务，确保所有任务都执行完毕后再进行清理工作。

通过掌握这些阻塞方法，你可以更好地控制线程的执行，提高程序的效率和响应速度。在实际开发中，根据具体需求选择合适的阻塞方法，可以使你的程序更加健壮和可靠。

-- 展开阅读全文 --