Java线程阻塞和唤醒的几种方式详解

更新时间：2023年10月26日 09:43:38 作者：Ramscy

这篇文章主要介绍了Java线程阻塞和唤醒的几种方式详解,线程阻塞是指当一个线程无法继续执行时,它会进入阻塞状态,直到某个条件满足后才能继续执行,线程阻塞可以通过多种方式实现,如等待锁、等待IO操作、等待其他线程的完成等,需要的朋友可以参考下

Object类自带的方法

使用wait()方法来阻塞线程，使用notify()和notifyAll()方法来唤醒线程。调用wait()方法后，线程将被阻塞，wait()方法将会释放当前持有的监视器锁(monitor)，直到有线程调用notify/notifyAll()方法后方能继续执行。 notify/notifyAll()方法只是解除了等待线程的阻塞，并不会马上释放监视器锁，而是在相应的被synchronized关键字修饰的同步方法或同步代码块执行结束后才自动释放锁。默认使用非公平锁，无法修改。

缺点：

使用几个方法时，必须处于被synchronized关键字修饰的同步方法或同步代码块中，否则程序运行时，会抛出IllegalMonitorStateException异常。
线程的唤醒必须在线程阻塞之后，否则，当前线程被阻塞之后，一直没有唤醒，线程将会一直等待下去（对比LockSupport）

public class SynchronizedDemo {

// 三个线程交替打印ABC
    public static void main(String[] args) {

        Print print = new Print();

        new Thread(() -> {
            while (true) {
                print.printA();
            }
        }, "A").start();
        new Thread(() -> {
            while (true) {
                print.printB();
            }
        }, "B").start();
        new Thread(() -> {
            while (true) {
                print.printC();
            }
        }, "C").start();
    }
}

class Print {

    Object object = new Object();
    int num = 1;

    public void printA() {
        synchronized (object) {
            try {
                while (num != 1) {
                    object.wait();
                }
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "==>A");
                }
                num = 2;
                object.notifyAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void printB() {
        synchronized (object) {
            try {
                while (num != 2) {
                    object.wait();
                }
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "==>B");
                }
                num = 3;
                object.notifyAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void printC() {
        synchronized (object) {
            try {
                while (num != 3) {
                    object.wait();
                }
                for (int i = 0; i < 15; i++) {
                    System.out.println(Thread.currentThread().getName() + "==>C");
                }
                num = 1;
                object.notifyAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Condition接口

使用await()方法来阻塞线程，signal()/singnalAll()方法来唤醒线程。

需要使用lock对象的newCondition()方法获得Condition条件对象（可有多个）。

可实现公平锁，默认是非公平锁

缺点：

必须被Lock包裹，否则会在运行时抛出IllegalMonitorStateException异常。
线程的唤醒必须在线程阻塞之后
Lock的实现是基于AQS，效率稍高于synchronized

public class ConditionDemo {

// 三个线程交替打印ABC
    public static void main(String[] args) {
        Print print = new Print();
        new Thread(() -> {
            while (true) {
                print.printA();
            }
        }, "A").start();

        new Thread(() -> {
            while (true) {
                print.printB();
            }
        }, "B").start();

        new Thread(() -> {
            while (true) {
                print.printC();
            }
        }, "C").start();
    }
}

class Print {

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num = 1;

    public void printA() {

        lock.lock();
        try {
            while (num != 1) {
                condition1.await();
            }
            for (int i = 0; i < 5; ++i) {
                System.out.println(Thread.currentThread().getName() + "==>A");
            }
            num = 2;
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB() {

        lock.lock();
        try {
            while (num != 2) {
                condition2.await();
            }
            for (int i = 0; i < 10; ++i) {
                System.out.println(Thread.currentThread().getName() + "==>B");
            }
            num = 3;
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC() {

        lock.lock();
        try {
            while (num != 3) {
                condition3.await();
            }
            for (int i = 0; i < 15; ++i) {
                System.out.println(Thread.currentThread().getName() + "==>C");
            }
            num = 1;
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

LockSupport

使用park()来阻塞线程，用unpark()方法来唤醒线程。这里有一个许可证的概念，许可不能累积，并且最多只能有一个许可，只有1和0的区别。

特点：

使用灵活，可以直接使用
线程唤醒可在线程阻塞之前，因为调用unpark()方法后，线程已经获得了一个许可证（但也只能有一个许可证），之后阻塞时，可以直接使用这个许可证来通行。
效率高

public class LockSupportDemo {

// 三个线程交替打印ABC
    public static void main(String[] args) throws Exception {

        Print print = new Print();

        Thread threadA = new Thread(() -> {
            while (true) {
                print.printA();
            }
        }, "A");

        Thread threadB = new Thread(() -> {
            while (true) {
                print.printB();
            }
        }, "B");

        Thread threadC = new Thread(() -> {
            while (true) {
                print.printC();
            }
        }, "C");

        threadA.start();
        threadB.start();
        threadC.start();

        while (true) {
            LockSupport.unpark(threadA);
            LockSupport.unpark(threadB);
            LockSupport.unpark(threadC);
        }

    }
}

class Print {

    private int num = 1;

    public void printA() {
        while (num != 1) {
            LockSupport.park();
        }
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "==>A");
        }
        num = 2;
    }

    public void printB() {
        while (num != 2) {
            LockSupport.park();
        }
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "==>B");
        }
        num = 3;
    }

    public void printC() {
        while (num != 3) {
            LockSupport.park();
        }
        for (int i = 0; i < 15; i++) {
            System.out.println(Thread.currentThread().getName() + "==>C");
        }
        num = 1;
    }
}

到此这篇关于Java线程阻塞和唤醒的几种方式详解的文章就介绍到这了,更多相关Java线程阻塞和唤醒内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

JDK1.8新特性Stream流式操作的具体使用
这篇文章主要介绍了JDK1.8新特性Stream流式操作的具体使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-09-09
java基本教程之java线程等待与java唤醒线程 java多线程教程
这篇文章主要介绍了对线程等待/唤醒方法,文中使用了多个示例，大家参考使用吧
2014-01-01
深入理解框架背后的原理及源码分析
这篇文章来为大家深入的介绍了框架背后的原理及源码分析，希望大家能够更深层次的理解并使用好框架，在此与君共勉，框架虽好，但不要丢了其背后的原理
2022-01-01
SpringMVC+EasyUI实现页面左侧导航菜单功能
这篇文章主要介绍了SpringMVC+EasyUI实现页面左侧导航菜单功能，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
2019-09-09
spring boot的maven配置依赖详解
本篇文章主要介绍了spring boot的maven配置依赖详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-11-11
java通过方法来交换实参的值实现方式
文章介绍了Java方法参数传递方式以及如何通过数组、自定义包装类或返回结果来实现变量交换,同时,讨论了内部类中static关键字的作用和使用场景
2025-12-12
Java中高效的判断数组中某个元素是否存在详解
相信大家在操作Java的时候，经常会要检查一个数组(无序)是否包含一个特定的值？这是一个在Java中经常用到的并且非常有用的操作。同时，这个问题在Stack Overflow中也是一个非常热门的问题。本文将分析几种常见用法及其时间成本，有需要的朋友们可以参考借鉴。
2016-11-11
SpringMVC教程之文件上传与下载详解
本文将对使用MultipartResolver处理文件上传的步骤，两种文件下载方式（直接向response的输出流中写入对应的文件流、使用 ResponseEntity<byte[]>来向前端返回文件）等进行详尽介绍，需要的可以参考一下
2022-12-12
简单实现Java通讯录系统
这篇文章主要为大家详细介绍了如何简单实现Java通讯录系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2018-02-02
MyBatisPlus之高级查询用法及说明
本文详细介绍了MyBatisPlus的高级查询函数,包括eq、ne、gt、gte、lt、lte、between、notBetween等、like、notLike等、inLeft、isNull、isNotNull、in、NotIn、InSql、NotInSql、GroupBy、OrderBy、Having、Apply、Exists、NotExists、Nested等等查询
2026-05-05

Java线程阻塞和唤醒的几种方式详解

目录

Object类自带的方法

Condition接口

LockSupport

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具