Java线程:线程的交互

简介: 一、线程交互的基础知识   SCJP所要求的线程交互知识点需要从java.lang.Object的类的三个方法来学习:    void notify()           唤醒在此对象监视器上等待的单个线程。
 
一、线程交互的基础知识
 
SCJP所要求的线程交互知识点需要从 java.lang.Object的类的三个方法来学习:
 
 void notify() 
          唤醒在此对象监视器上等待的单个线程。 
 void notifyAll() 
          唤醒在此对象监视器上等待的所有线程。 
 void wait() 
          导致当前的线程等待,直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
 
当然,wait()还有另外两个重载方法:
 void wait(long timeout) 
          导致当前的线程等待,直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量。 
 void wait(long timeout, int nanos) 
          导致当前的线程等待,直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量。
 
以上这些方法是帮助线程传递线程关心的时间状态。
 
关于等待/通知,要记住的关键点是:
必须从同步环境内调用wait()、notify()、notifyAll()方法。线程不能调用对象上等待或通知的方法,除非它拥有那个对象的锁。
wait()、notify()、notifyAll()都是Object的实例方法。与每个对象具有锁一样,每个对象可以有一个线程列表,他们等待来自该信号(通知)。线程通过执行对象上的wait()方法获得这个等待列表。从那时候起,它不再执行任何其他指令,直到调用对象的notify()方法为止。如果多个线程在同一个对象上等待,则将只选择一个线程(不保证以何种顺序)继续执行。如果没有线程等待,则不采取任何特殊操作。
 
下面看个例子就明白了:
/** 
* 计算输出其他线程锁计算的数据 

* @author leizhimin 2008-9-15 13:20:38 
*/
 
public  class ThreadA { 
     public  static  void main(String[] args) { 
        ThreadB b =  new ThreadB(); 
         //启动计算线程 
        b.start(); 
         //线程A拥有b对象上的锁。线程为了调用wait()或notify()方法,该线程必须是那个对象锁的拥有者 
         synchronized (b) { 
             try { 
                System.out.println( "等待对象b完成计算。。。"); 
                 //当前线程A等待 
                b.wait(); 
            }  catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
            System.out.println( "b对象计算的总和是:" + b.total); 
        } 
    } 
}
 
/** 
* 计算1+2+3 ... +100的和 

* @author leizhimin 2008-9-15 13:20:49 
*/
 
public  class ThreadB  extends Thread { 
     int total; 

     public  void run() { 
         synchronized ( this) { 
             for ( int i = 0; i < 101; i++) { 
                total += i; 
            } 
             //(完成计算了)唤醒在此对象监视器上等待的单个线程,在本例中线程A被唤醒 
            notify(); 
        } 
    } 
}
 
等待对象b完成计算。。。 
b对象计算的总和是:5050 

Process finished with exit code 0 
 
千万注意:
当在对象上调用wait()方法时,执行该代码的线程立即放弃它在对象上的锁。然而调用notify()时,并不意味着这时线程会放弃其锁。如果线程荣然在完成同步代码,则线程在移出之前不会放弃锁。因此,只要调用notify()并不意味着这时该锁变得可用。
 
二、多个线程在等待一个对象锁时候使用notifyAll()
 
在多数情况下,最好通知等待某个对象的所有线程。如果这样做,可以在对象上使用notifyAll()让所有在此对象上等待的线程冲出等待区,返回到可运行状态。
 
下面给个例子:
/** 
* 计算线程 

* @author leizhimin 2008-9-20 11:15:46 
*/
 
public  class Calculator  extends Thread { 
         int total; 

         public  void run() { 
                 synchronized ( this) { 
                         for ( int i = 0; i < 101; i++) { 
                                total += i; 
                        } 
                } 
                 //通知所有在此对象上等待的线程 
                notifyAll(); 
        } 
}
 
/** 
* 获取计算结果并输出 

* @author leizhimin 2008-9-20 11:15:22 
*/
 
public  class ReaderResult  extends Thread { 
        Calculator c; 

         public ReaderResult(Calculator c) { 
                 this.c = c; 
        } 

         public  void run() { 
                 synchronized (c) { 
                         try { 
                                System.out.println(Thread.currentThread() +  "等待计算结果。。。"); 
                                c.wait(); 
                        }  catch (InterruptedException e) { 
                                e.printStackTrace(); 
                        } 
                        System.out.println(Thread.currentThread() +  "计算结果为:" + c.total); 
                } 
        } 

         public  static  void main(String[] args) { 
                Calculator calculator =  new Calculator(); 

                 //启动三个线程,分别获取计算结果 
                 new ReaderResult(calculator).start(); 
                 new ReaderResult(calculator).start(); 
                 new ReaderResult(calculator).start(); 
                 //启动计算线程 
                calculator.start(); 
        } 
}
 
运行结果:
Thread[Thread-1,5,main]等待计算结果。。。 
Thread[Thread-2,5,main]等待计算结果。。。 
Thread[Thread-3,5,main]等待计算结果。。。 
Exception in thread  "Thread-0" java.lang.IllegalMonitorStateException: current thread not owner 
  at java.lang.Object.notifyAll(Native Method) 
  at threadtest.Calculator.run(Calculator.java:18) 
Thread[Thread-1,5,main]计算结果为:5050 
Thread[Thread-2,5,main]计算结果为:5050 
Thread[Thread-3,5,main]计算结果为:5050 

Process finished with exit code 0 
 
运行结果表明,程序中有异常,并且多次运行结果可能有多种输出结果。这就是说明,这个多线程的交互程序还存在问题。究竟是出了什么问题,需要深入的分析和思考,下面将做具体分析。
 
实际上,上面这个代码中,我们期望的是读取结果的线程在计算线程调用notifyAll()之前等待即可。 但是,如果计算线程先执行,并在读取结果线程等待之前调用了notify()方法,那么又会发生什么呢?这种情况是可能发生的。因为无法保证线程的不同部分将按照什么顺序来执行。幸运的是当读取线程运行时,它只能马上进入等待状态----它没有做任何事情来检查等待的事件是否已经发生。  ----因此,如果计算线程已经调用了notifyAll()方法,那么它就不会再次调用notifyAll(),----并且等待的读取线程将永远保持等待。这当然是开发者所不愿意看到的问题。
 
因此,当等待的事件发生时,需要能够检查notifyAll()通知事件是否已经发生。
 

通常,解决上面问题的最佳方式是将

原文链接 :http://lavasoft.blog.51cto.com/62575/99157

 
倾城之链 | NICE LINKS DJI Mavic Air
目录
相关文章
|
9天前
|
监控 安全 Java
在 Java 中使用线程池监控以及动态调整线程池时需要注意什么?
【10月更文挑战第22天】在进行线程池的监控和动态调整时,要综合考虑多方面的因素,谨慎操作,以确保线程池能够高效、稳定地运行,满足业务的需求。
81 38
|
6天前
|
安全 Java
java 中 i++ 到底是否线程安全?
本文通过实例探讨了 `i++` 在多线程环境下的线程安全性问题。首先,使用 100 个线程分别执行 10000 次 `i++` 操作,发现最终结果小于预期的 1000000,证明 `i++` 是线程不安全的。接着,介绍了两种解决方法:使用 `synchronized` 关键字加锁和使用 `AtomicInteger` 类。其中,`AtomicInteger` 通过 `CAS` 操作实现了高效的线程安全。最后,通过分析字节码和源码,解释了 `i++` 为何线程不安全以及 `AtomicInteger` 如何保证线程安全。
java 中 i++ 到底是否线程安全?
|
11天前
|
Java 调度
[Java]线程生命周期与线程通信
本文详细探讨了线程生命周期与线程通信。文章首先分析了线程的五个基本状态及其转换过程,结合JDK1.8版本的特点进行了深入讲解。接着,通过多个实例介绍了线程通信的几种实现方式,包括使用`volatile`关键字、`Object`类的`wait()`和`notify()`方法、`CountDownLatch`、`ReentrantLock`结合`Condition`以及`LockSupport`等工具。全文旨在帮助读者理解线程管理的核心概念和技术细节。
27 1
[Java]线程生命周期与线程通信
|
1天前
|
存储 设计模式 分布式计算
Java中的多线程编程:并发与并行的深度解析####
在当今软件开发领域,多线程编程已成为提升应用性能、响应速度及资源利用率的关键手段之一。本文将深入探讨Java平台上的多线程机制,从基础概念到高级应用,全面解析并发与并行编程的核心理念、实现方式及其在实际项目中的应用策略。不同于常规摘要的简洁概述,本文旨在通过详尽的技术剖析,为读者构建一个系统化的多线程知识框架,辅以生动实例,让抽象概念具体化,复杂问题简单化。 ####
|
2天前
|
Java 开发者
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
12 4
|
2天前
|
消息中间件 供应链 Java
掌握Java多线程编程的艺术
【10月更文挑战第29天】 在当今软件开发领域,多线程编程已成为提升应用性能和响应速度的关键手段之一。本文旨在深入探讨Java多线程编程的核心技术、常见问题以及最佳实践,通过实际案例分析,帮助读者理解并掌握如何在Java应用中高效地使用多线程。不同于常规的技术总结,本文将结合作者多年的实践经验,以故事化的方式讲述多线程编程的魅力与挑战,旨在为读者提供一种全新的学习视角。
20 3
|
8天前
|
安全 Java
在 Java 中使用实现 Runnable 接口的方式创建线程
【10月更文挑战第22天】通过以上内容的介绍,相信你已经对在 Java 中如何使用实现 Runnable 接口的方式创建线程有了更深入的了解。在实际应用中,需要根据具体的需求和场景,合理选择线程创建方式,并注意线程安全、同步、通信等相关问题,以确保程序的正确性和稳定性。
|
3天前
|
安全 Java 调度
Java中的多线程编程入门
【10月更文挑战第29天】在Java的世界中,多线程就像是一场精心编排的交响乐。每个线程都是乐团中的一个乐手,他们各自演奏着自己的部分,却又和谐地共同完成整场演出。本文将带你走进Java多线程的世界,让你从零基础到能够编写基本的多线程程序。
12 1
|
7天前
|
缓存 Java 调度
Java中的多线程编程:从基础到实践
【10月更文挑战第24天】 本文旨在为读者提供一个关于Java多线程编程的全面指南。我们将从多线程的基本概念开始,逐步深入到Java中实现多线程的方法,包括继承Thread类、实现Runnable接口以及使用Executor框架。此外,我们还将探讨多线程编程中的常见问题和最佳实践,帮助读者在实际项目中更好地应用多线程技术。
15 3
|
9天前
|
监控 安全 Java
Java多线程编程的艺术与实践
【10月更文挑战第22天】 在现代软件开发中,多线程编程是一项不可或缺的技能。本文将深入探讨Java多线程编程的核心概念、常见问题以及最佳实践,帮助开发者掌握这一强大的工具。我们将从基础概念入手,逐步深入到高级主题,包括线程的创建与管理、同步机制、线程池的使用等。通过实际案例分析,本文旨在提供一种系统化的学习方法,使读者能够在实际项目中灵活运用多线程技术。