多线程之Java线程阻塞与唤醒

简介: 线程的阻塞和唤醒在多线程并发过程中是一个关键点,当线程数量达到很大的数量级时,并发可能带来很多隐蔽的问题。如何正确暂停一个线程,暂停后又如何在一个要求的时间点恢复,这些都需要仔细考虑的细节。

线程的阻塞和唤醒在多线程并发过程中是一个关键点,当线程数量达到很大的数量级时,并发可能带来很多隐蔽的问题。如何正确暂停一个线程,暂停后又如何在一个要求的时间点恢复,这些都需要仔细考虑的细节。在Java发展史上曾经使用suspend()、resume()方法对于线程进行阻塞唤醒,但随之出现很多问题,比较典型的还是死锁问题。如下代码,主要的逻辑代码是主线程启动线程mt一段时间后尝试使用suspend()让线程挂起,最后使用resume()恢复线程。但现实并不如愿,执行到suspend()时将一直卡住,你等不来“canyou get here?”的输出。

public class ThreadSuspend {

public static voidmain(String[] args) {

     Thread mt = newMyThread();

     mt.start();

     try {

          Thread.currentThread().sleep(100);

     } catch(InterruptedException e) {

          e.printStackTrace();

     }

     mt.suspend();

     System.out.println("canyou get here?");

     mt.resume();

}

 

static class MyThreadextends Thread {

     public void run() {

          while (true) {

              System.out.println("running....");

          }

     }

}

}

产生上面所述现象其实是由死锁导致,看起来一点问题都没有,线程的任务仅仅只是简单地打印字符串,问题的根源隐藏得较深,主线程启动了线程mt后,线程mt开始执行execute()方法,不断打印字符串,问题正是出现在System.out.println,由于println被声明为一个同步方法,执行时将对System类的out(PrintStream类的一个实例)单例属性加同步锁,而suspend()方法挂起线程但并不释放锁,在线程mt被挂起后主线程调用System.out.println同样需要获取System类out对象的同步锁才能打印“can you get here?”,主线程一直在等待同步锁而mt线程不释放锁,这就导致了死锁的产生。

可见suspend和resume有死锁倾向,一不小心将导致很多问题,甚至导致整个系统崩溃。也许,解决方案可以使用以对象为目标的阻塞,即利用Object类的wait()和notify()方法实现线程阻塞。针对对象的阻塞编程思维需要稍微转化下,它与面向线程阻塞思维有较大差异,如前面的suspend与resume只需在线程内直接调用就能完成挂起恢复操作,这个很好理解,而如果改用wait、notify形式则通过一个object作为信号,可以看成是一堵门,object的wait()方法是锁门的动作,notify()是开门的动作,某一线程一旦关上门后其他线程都将阻塞,直到别的线程打开门。如图2-5-8-4,一个对象object调用wait()方法则像是堵了一扇门,线程一、线程二都将阻塞,线程三调用object的notify()方法打开门(准确说是调用了notifyAll()方法,notify()仅仅能让线程一或线程二其中一条线程通过),线程一、线程二得以通过。

图2-5-8-4

使用wait和notify能规避死锁问题,但并不能完全避免,必须在编程过程中避免死锁。在使用过程中需要注意的几点是:首先,wait、notify方法是针对对象的,调用任意对象的wait()方法都将导致线程阻塞,阻塞的同时也将释放该对象的锁,相应地,调用任意对象的notify()方法则将随机解除该对象阻塞的线程,但它需要重新获取改对象的锁,直到获取成功才能往下执行;其次,wait、notify方法必须在synchronized块或方法中被调用,并且要保证同步块或方法的锁对象与调用wait、notify方法的对象是同一个,如此一来在调用wait之前当前线程就已经成功获取某对象的锁,执行wait阻塞后当前线程就将之前获取的对象锁释放。当然假如你不按照上面规定约束编写,程序一样能通过编译,但运行时将抛出IllegalMonitorStateException异常,必须在编写时保证用法正确;最后,notify是随机唤醒一条阻塞中的线程并让之获取对象锁,进而往下执行,而notifyAll则是唤醒阻塞中的所有线程,让他们去竞争该对象锁,获取到锁的那条线程才能往下执行。

通过wait、notify改造上面的例子,代码如下,改造的思想就是在MyThread中添加一个标识变量,一旦变量改变就相应地调用wait和notify阻塞唤醒线程,由于在执行wait后将释放synchronized (this)锁住的对象锁,此时System.out.println("running....");早已执行完毕,System类out对象不存在死锁问题。

publicclass ThreadWait {

     public static void main(String[] args) {

         MyThread mt = new MyThread();

         mt.start();

         try {

              Thread.currentThread().sleep(10);

         } catch (InterruptedException e) {

              e.printStackTrace();

         }

         mt.suspendThread();

         System.out.println("can you gethere?");

         try {

              Thread.currentThread().sleep(3000);

         } catch (InterruptedException e) {

              e.printStackTrace();

         }

         mt.resumeThread();

     }

}

 

classMyThread extends Thread {

     public boolean stop = false;

     public void run() {

         while (true) {

              synchronized (this) {

                   System.out.println("running....");

                   if (stop)

                       try {

                            wait();

                       } catch(InterruptedException e) {

                            e.printStackTrace();

                       }

              }

         }

     }

 

     public void suspendThread() {

         this.stop = true;

     }

 

     public void resumeThread() {

         synchronized (this) {

              this.stop = false;

              notify();

          }

     }

}

wait与notify组合的方式看起来是个不错的解决方式,但其面向的主体是对象object,阻塞的是当前线程,而唤醒的是随机的某个线程或所有线程,偏重于线程之间的通信交互。假如换个角度,面向的主体是线程的话,我就能轻而易举地对指定的线程进行阻塞唤醒,这个时候就需要LockSupport,它提供的park和unpark方法分别用于阻塞和唤醒,而且它提供避免死锁和竞态条件,很好地代替suspend和resume组合。用park和unpark改造上述例子,代码如下:

public class ThreadPark {

public static voidmain(String[] args) {

           MyThreadmt = new MyThread();

           mt.start();

           try {

                    Thread.currentThread().sleep(10);

           } catch(InterruptedException e) {

                    e.printStackTrace();

           }

           mt.park();

           System.out.println("canyou get here?");

           try {

                    Thread.currentThread().sleep(3000);

           } catch(InterruptedException e) {

                    e.printStackTrace();

           }

           mt.unPark();

}

 

static classMyThread extends Thread {

           privateboolean isPark=false;

           publicvoid run() {

                    while(true) {

                             if(isPark)

                                       LockSupport.park();

                             System.out.println("running....");

                    }

           }

    public void park(){

    isPark=true;

    }

    public void unPark(){

    isPark=false;

     LockSupport.unpark(this);

    }

}

}

把主体换成线程进行的阻塞看起来貌似比较顺眼,而且由于park与unpark方法控制的颗粒度更加细小,能准确决定线程在某个点停止,进而避免死锁的产生,例如此例中在执行System.out.println前线程就被阻塞了,于是不存在因竞争System类out对象而产生死锁,即便在执行System.out.println后线程才阻塞也不存在死锁问题,因为锁已释放。

LockSupport类为线程阻塞唤醒提供了基础,同时,在竞争条件问题上,它具有wait和notify无可比拟的优势。使用wait和notify组合时,某一线程在被另一线程notify之前必须要保证此线程已经执行到wait等待点,错过notify则可能永远都在等待,另外notify也不能保证唤醒指定的某线程。反观LockSupport,由于park与unpark引入了许可机制,许可逻辑为:①park将许可在等于0的时候阻塞,等于1的时候返回并将许可减为0;②unpark尝试唤醒线程,许可加1。根据这两个逻辑,对于同一条线程,park与unpark先后操作的顺序似乎并不影响程序正确地执行,假如先执行unpark操作,许可则为1,之后再执行park操作,此时因为许可等于1直接返回往下执行,并不执行阻塞操作。

最后,LockSupport的park与unpark组合真正解耦了线程之间的同步,不再需要另外的对象变量存储状态,并且也不需要考虑同步锁,wait与notify要保证必须有锁才能执行,而且执行notify操作释放锁后还要将当前线程扔进该对象锁的等待队列,LockSupport则完全不用考虑对象、锁、等待队列等问题。


点击订购作者书籍《Tomcat内核设计剖析》



目录
相关文章
|
1天前
|
Java
死锁是线程间争夺资源造成的无限等待现象,Java示例展示了两个线程各自持有资源并等待对方释放,导致死锁。`
【6月更文挑战第20天】死锁是线程间争夺资源造成的无限等待现象,Java示例展示了两个线程各自持有资源并等待对方释放,导致死锁。`volatile`保证变量的可见性和部分原子性,确保多线程环境中值的即时更新。与`synchronized`相比,`volatile`作用于单个变量,不保证原子操作,同步范围有限,但开销较小。`synchronized`提供更全面的内存语义,保证原子性和可见性,适用于复杂并发控制。
11 3
|
18小时前
|
安全 Java
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
【6月更文挑战第20天】JAVA多线程中,wait(), notify(), notifyAll()是Object类的关键同步机制。wait()让线程等待并释放锁,直到被notify()或notifyAll()唤醒或超时。它们必须在同步块中使用,持有锁的线程调用。notify()唤醒一个等待线程,notifyAll()唤醒所有。最佳实践包括:与synchronized结合,循环检查条件,避免循环内notify(),通常优先使用notifyAll()。
|
20小时前
|
缓存 安全 Java
java线程面试题2019最新整理
java线程面试题2019最新整理
|
1天前
|
Java
你还在单线程里奋斗?来看看 Java 多线程创建的魅力!
【6月更文挑战第19天】单线程程序中任务依次执行导致效率低,而Java多线程可并行处理任务,提高效率。在示例中,多线程版本并行运行三个任务,减少总耗时,展示出多线程在处理并发和提升响应速度上的优势。使用`Thread`类创建线程,通过`start()`启动,`join()`确保所有线程执行完毕,揭示了多线程在编程中的强大潜力。
|
1天前
|
Java 开发者
线程的诞生之路:Java多线程创建方法的抉择与智慧
【6月更文挑战第19天】Java多线程编程中,开发者可选择继承Thread类或实现Runnable接口。继承Thread直接但受限于单继承,适合简单场景;实现Runnable更灵活,支持代码复用,适用于如银行转账这类需多线程处理的复杂任务。在资源管理和任务执行控制上,Runnable接口通常更优。
|
1天前
|
Java
Java 多线程新手必读:线程的创建技巧与陷阱
【6月更文挑战第19天】Java多线程初学者须知:创建线程可通过继承`Thread`或实现`Runnable`接口。继承`Thread`限制单继承,实现`Runnable`更灵活。记得调用`start()`而非`run()`启动线程,避免并发问题时需正确同步共享资源。示例代码展示两种创建方式及未同步导致的问题。
|
算法 Java 测试技术
Java长度为0的阻塞对列-TransferQueue详解
Java长度为0的阻塞对列-TransferQueue详解
129 0
|
1天前
|
Java
【技术瑜伽师】Java 线程:修炼生命周期的平衡之道,达到多线程编程的最高境界!
【6月更文挑战第19天】Java多线程编程犹如瑜伽修行,从创建线程开始,如`new Thread(Runnable)`,到启动线程的活跃,用`start()`赋予生命。面对竞争与冲突,借助同步机制保证资源访问的有序,如`synchronized`关键字。线程可能阻塞等待,如同瑜伽的静止与耐心。完成任务后线程终止,整个过程需密切关注状态变换,以求多线程间的和谐与平衡。持续修炼,如同瑜伽般持之以恒,实现高效稳定的多线程程序。
|
1天前
|
Java
【代码诗人】Java线程的生与死:一首关于生命周期的赞歌!
【6月更文挑战第19天】Java线程生命周期,如诗般描绘了从新建到死亡的旅程:创建后待命,`start()`使其就绪,获得CPU则运行,等待资源则阻塞,任务完或中断即死亡。理解生命周期,善用锁、线程池,优雅处理异常,确保程序高效稳定。线程管理,既是艺术,也是技术。
|
1天前
|
安全 Java
【极客档案】Java 线程:解锁生命周期的秘密,成为多线程世界的主宰者!
【6月更文挑战第19天】Java多线程编程中,掌握线程生命周期是关键。创建线程可通过继承`Thread`或实现`Runnable`,调用`start()`使线程进入就绪状态。利用`synchronized`保证线程安全,处理阻塞状态,注意资源管理,如使用线程池优化。通过实践与总结,成为多线程编程的专家。