当前位置：首页 > news >正文

【Java基础-50.1】Java线程阻塞详解：类型、实现与案例分析

news 来源：原创 2025/5/3 15:05:50

在Java多线程编程中，线程阻塞是一个常见的现象。线程阻塞指的是线程因为某些原因暂时停止执行，等待条件满足后再继续执行。理解线程阻塞的类型及其实现方式，对于编写高效、可靠的多线程程序至关重要。本文将深入探讨Java中线程阻塞的几种类型，并通过具体案例帮助你更好地理解和应用这些概念。

1. 线程阻塞的基本概念

1.1 什么是线程阻塞？

线程阻塞是指线程在执行过程中因为某些原因暂时停止执行，进入等待状态。常见的阻塞原因包括等待I/O操作完成、等待锁释放、等待条件满足等。线程阻塞是Java多线程编程中的一种重要机制，用于协调多个线程的执行顺序和资源共享。

1.2 线程阻塞与线程状态

在Java中，线程的状态由Thread.State枚举表示，包括以下几种状态：

NEW：线程刚创建，尚未启动。
RUNNABLE：线程正在运行或准备运行。
BLOCKED：线程被阻塞，等待获取锁。
WAITING：线程无限期等待，直到被其他线程显式唤醒。
TIMED_WAITING：线程在指定的时间内等待。
TERMINATED：线程执行完毕。

线程阻塞通常与BLOCKED、WAITING和TIMED_WAITING状态相关。

2. Java中线程阻塞的几种类型

2.1 I/O阻塞

I/O阻塞是指线程在执行I/O操作（如读取文件、网络通信等）时，由于I/O操作未完成而进入阻塞状态。I/O操作通常是同步的，线程会一直等待直到操作完成。

案例：文件读取阻塞

import java.io.FileInputStream;
import java.io.IOException;

public class IOBlockingExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("example.txt")) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                System.out.println(new String(buffer, 0, bytesRead));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的例子中，fis.read(buffer)是一个阻塞操作，线程会一直等待直到文件读取完成。

2.2 锁阻塞

锁阻塞是指线程在尝试获取一个已经被其他线程持有的锁时，进入阻塞状态。Java中的synchronized关键字和ReentrantLock类都可以导致锁阻塞。

案例：synchronized锁阻塞

public class LockBlockingExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1 acquired the lock");
                try {
                    Thread.sleep(2000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 acquired the lock");
            }
        });

        t1.start();
        t2.start();
    }
}

在上面的例子中，t2线程在尝试获取lock时会被阻塞，直到t1线程释放锁。

2.3 条件阻塞

条件阻塞是指线程在等待某个条件满足时进入阻塞状态。Java中的wait()、notify()和notifyAll()方法以及Condition接口都可以实现条件阻塞。

案例：wait/notify条件阻塞

public class ConditionBlockingExample {
    private static final Object lock = new Object();
    private static boolean condition = false;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                while (!condition) {
                    try {
                        System.out.println("Thread 1 is waiting");
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("Thread 1 is running");
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 is running");
                condition = true;
                lock.notify();
            }
        });

        t1.start();
        t2.start();
    }
}

在上面的例子中，t1线程在condition为false时会进入阻塞状态，直到t2线程将condition设置为true并调用notify()方法唤醒t1。

2.4 睡眠阻塞

睡眠阻塞是指线程通过调用Thread.sleep()方法主动进入阻塞状态，暂停执行一段时间。

案例：Thread.sleep睡眠阻塞

public class SleepBlockingExample {
    public static void main(String[] args) {
        System.out.println("Thread is running");
        try {
            Thread.sleep(2000); // 线程睡眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread is awake");
    }
}

在上面的例子中，线程会睡眠2秒，然后继续执行。

2.5 等待超时阻塞

等待超时阻塞是指线程在等待某个条件满足时，如果在指定时间内条件未满足，则自动唤醒。Java中的wait(long timeout)和join(long millis)方法可以实现等待超时阻塞。

案例：wait(long timeout)等待超时阻塞

public class TimedWaitBlockingExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1 is waiting");
                    lock.wait(2000); // 等待2秒
                    System.out.println("Thread 1 is awake");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
    }
}

在上面的例子中，t1线程会等待2秒，如果在这段时间内没有被唤醒，则会自动继续执行。

3. 线程阻塞的应用场景

3.1 生产者-消费者模型

生产者-消费者模型是多线程编程中的经典问题，通过线程阻塞和唤醒机制可以很好地实现生产者和消费者之间的协调。

import java.util.LinkedList;
import java.util.Queue;

public class ProducerConsumerExample {
    private static final int CAPACITY = 5;
    private static final Queue<Integer> queue = new LinkedList<>();

    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            int value = 0;
            while (true) {
                synchronized (queue) {
                    while (queue.size() == CAPACITY) {
                        try {
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    queue.add(value);
                    System.out.println("Produced: " + value);
                    value++;
                    queue.notifyAll();
                }
            }
        });

        Thread consumer = new Thread(() -> {
            while (true) {
                synchronized (queue) {
                    while (queue.isEmpty()) {
                        try {
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int value = queue.poll();
                    System.out.println("Consumed: " + value);
                    queue.notifyAll();
                }
            }
        });

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