精华内容
下载资源
问答
  • 线程唤醒问题

    2020-05-16 12:02:23
    2.在另一个已经实现好了的具有定帧功能的线程里,每次用 sem_post 来唤醒这个定时器检查线程。 在不考虑时间精度的情况下,虽然定帧线程由于执行其他逻辑可能会有延迟的情况出现,但是误差可以接受。 因为我...
  • java 中wait和notify 线程等待和线程唤醒的使用方式 需要借助synchronized

    			synchronized(lockObj)
    			{
    				message.setContent("LST-UNREGONU::OLTID=136.1.1.100,PONID=1-1-1-2:CTAG::;");
    				nettyClient.sendMessage(message, listener);	
    				lockObj.wait();
    			}
    
                            synchronized (lockObj) {
    					messageForRcv.setContent(result.toString());
    					lockObj.notify();
    		     }


    展开全文
  • Java——设置线程等待与线程唤醒

    千次阅读 2017-10-10 14:49:24
    //线程间的通信:线程的任务...指明让持有哪个锁的线程去等待或被唤醒 */ //还是上次的例子,实现存一个输出一个,而不是输出一大堆//描述数据 class Res{ String name; String sex; //加一个flag标记,false表示没
    //线程间的通信:线程的任务不同,但是线程操作的数据相同
    /*
    wait(),notify(),notifyAll()必须用在同步中,因为同步中才有锁
    指明让持有哪个锁的线程去等待或被唤醒
    */
    //还是上次的例子,实现存一个输出一个,而不是输出一大堆
    
    //描述数据
    class Res{
        String name;
        String sex;
        //加一个flag标记,false表示没有数据
        //false即可以存,存完之后,flag改为true,唤醒输出线程,然后放弃CPU,让他等待
        //等输出数据的任务输出一组数据后,把输入的线程唤醒,把flag改为false,
        //然后放弃CPU,即让其也进入等待状态,再让输入线程接着存
        boolean flag = false;
    }
    //利用构造函数,把同一个res传给输入任务和输出任务
    //即保证了两者为同一个res
    //描述输入任务
    class Input implements Runnable{
        private Res res;
        //两个线程同一把锁才能实现互相排斥,所以不用obj锁,用res当锁
        //private Object obj = new Object();
        public Input(Res res){
            this.res = res;
        }
        public void run(){
            int i = 1;
            while(true){
                //下面的if条件语句和else中的语句存在安全问题
                //因为是两句话,中间有可能被其他线程抢走CPU
                //所以在输出的时候会有“张三....女”这样的输出
                //解决四路:存数据的时候不能输出
                //方法,对t1和t2两个线程进行同步操作,但是要保证用
                //同一把锁,所以不能再用obj锁
                /*if(i==1){
                    res.name = "张三";
                    res.sex = "男";
                }else{  
                    res.name = "李四";
                    res.sex = "女";
                }*/
                synchronized(res){
                    //先判断该不该存
                    //如果flag是true,说明有数据,不能输入,让其等待
                    //wait()方法必须用在同步当中,因为同步当中才有锁
                    if(res.flag){
                        //wait前加res的原因,因为有可能有其他线程,其他锁
                        //通过锁来执行,让哪个线程来等待
                        //等待的线程会放弃锁
                        try{res.wait();}catch(InterruptedException e){e.printStackTrace();}
                    }
                    //如果是false,输入数据
                    if(i==1){
                        res.name = "张三";
                        res.sex = "男";
                    }else{  
                        res.name = "李四";
                        res.sex = "女";
                    }
                    //输入完成后将flag标志改为true,意思是可以输出了
                    res.flag = true;
                    res.notify();//唤醒输出线程,允许空唤醒,即没有需要被唤醒的也可以
                }
                //1 0切换
                i = (i+1)%2;
            }
        }
    }
    //描述输出任务
    class Output implements Runnable{
        private Res res;
        public Output(Res res){
            this.res = res;
        }
        public void run(){
            while(true){
                synchronized(res){
                    //判断该不该输出
                    //如果flag是false,则没有数据可以输出,让其等待
                    if(!res.flag){
                        try{res.wait();}catch(InterruptedException e){e.printStackTrace();}
                    }
                    System.out.println(res.name+"...."+res.sex);
                    //把flag改为false,意思是可以进行输入了
                    res.flag = false;
                    //唤醒输入进程
                    res.notify();
                }
            }
        }
    }
    class test{
        public static void main(String[] args){
            //创建资源对象
            Res res = new Res();
    
            //输入任务和输出任务用同一个对象,即相同的资源
    
            //创建输入任务
            Input in = new Input(res);
    
            //创建输出任务
            Output out = new Output(res);
    
            //创建输入线程
            Thread t1 = new Thread(in);
    
            //创建输出线程
            Thread t2 = new Thread(out);
    
            t1.start();
            t2.start();
        }
    }
    展开全文
  • Java线程唤醒与阻塞

    千次阅读 2016-10-09 09:37:18
    阻塞指的是暂停一个线程的执行以等待某个条件发生(如某资源就绪),学过操作系统的同学对它一 定已经很熟悉了。Java 提供了大量方法来支持阻塞,下面让我们逐一分析。 转载于:...

    阻塞指的是暂停一个线程的执行以等待某个条件发生(如某资源就绪),学过操作系统的同学对它一
    定已经很熟悉了。Java 提供了大量方法来支持阻塞,下面让我们逐一分析。
    转载于:
    http://blog.csdn.net/small____fish/article/details/7726468
      1. sleep() 方法:sleep() 允许 指定以毫秒为单位的一段时间作为参数,它使得线程在指定的时间
    内进入阻塞状态,不能得到CPU 时间,指定的时间一过,线程重新进入可执行状态。
      典型地,sleep() 被用在等待某个资源就绪的情形:测试发现条件不满足后,让线程阻塞一段时间后
    重新测试,直到条件满足为止。
      2. suspend() 和 resume() 方法:两个方法配套使用,suspend()使得线程进入阻塞状态,并且不会
    自动恢复,必须其对应的resume() 被调用,才能使得线程重新进入可执行状态。典型地,suspend() 和 
    resume() 被用在等待另一个线程产生的结果的情形:测试发现结果还没有产生后,让线程阻塞,另一个
    线程产生了结果后,调用 resume() 使其恢复。
      3. yield() 方法:yield() 使得线程放弃当前分得的 CPU 时间,但是不使线程阻塞,即线程仍处于
    可执行状态,随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足
    够的时间从而转到另一个线程。
      4. wait() 和 notify() 方法:两个方法配套使用,wait() 使得线程进入阻塞状态,它有两种形式
    ,一种允许指定以毫秒为单位的一段时间作为参数,另一种没有参数,前者当对应的 notify() 被调用或
    者超出指定时间时线程重新进入可执行状态,后者则必须对应的 notify() 被调用。
      初看起来它们与 suspend() 和 resume() 方法对没有什么分别,但是事实上它们是截然不同的。区
    别的核心在于,前面叙述的所有方法,阻塞时都不会释放占用的锁(如果占用了的话),而这一对方法则
    相反。

      上述的核心区别导致了一系列的细节上的区别。

      首先,前面叙述的所有方法都隶属于 Thread 类,但是这一对却直接隶属于 Object 类,也就是说,
    所有对象都拥有这一对方法。初看起来这十分不可思议,但是实际上却是很自然的,因为这一对方法阻塞
    时要释放占用的锁,而锁是任何对象都具有的,调用任意对象的 wait() 方法导致线程阻塞,并且该对象
    上的锁被释放。而调用 任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随
    机选择的一个解除阻塞(但要等到获得锁后才真正可执行)。

      其次,前面叙述的所有方法都可在任何位置调用,但是这一对方法却必须在 synchronized 方法或块
    中调用,理由也很简单,只有在synchronized 方法或块中当前线程才占有锁,才有锁可以释放。同样的
    道理,调用这一对方法的对象上的锁必须为当前线程所拥有,这样才有锁可以释放。因此,这一对方法调
    用必须放置在这样的 synchronized 方法或块中,该方法或块的上锁对象就是调用这一对方法的对象。若
    不满足这一条件,则程序虽然仍能编译,但在运行时会出现 IllegalMonitorStateException 异常。

      wait() 和 notify() 方法的上述特性决定了它们经常和synchronized 方法或块一起使用,将它们和
    操作系统的进程间通信机制作一个比较就会发现它们的相似性:synchronized方法或块提供了类似于操作
    系统原语的功能,它们的执行不会受到多线程机制的干扰,而这一对方法则相当于 block 和wakeup 原语
    (这一对方法均声明为 synchronized)。它们的结合使得我们可以实现操作系统上一系列精妙的进程间
    通信的算法(如信号量算法),并用于解决各种复杂的线程间通信问题。

      关于 wait() 和 notify() 方法最后再说明两点:
      第一:调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随
    机选取的,我们无法预料哪一个线程将会被选择,所以编程时要特别小心,避免因这种不确定性而产生问
    题。

      第二:除了 notify(),还有一个方法 notifyAll() 也可起到类似作用,唯一的区别在于,调用 
    notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然,只有
    获得锁的那一个线程才能进入可执行状态。
      谈到阻塞,就不能不谈一谈死锁,略一分析就能发现,suspend() 方法和不指定超时期限的 wait() 
    方法的调用都可能产生死锁。遗憾的是,Java 并不在语言级别上支持死锁的避免,我们在编程中必须小
    心地避免死锁。

      以上我们对 Java 中实现线程阻塞的各种方法作了一番分析,我们重点分析了 wait() 和 notify() 
    方法,因为它们的功能最强大,使用也最灵活,但是这也导致了它们的效率较低,较容易出错。实际使用
    中我们应该灵活使用各种方法,以便更好地达到我们的目的。

     

     

    总结:

    wait和notify、notifyall方法属于Object类,它们涉及到锁的释放问题,所以和synchronized关键字一起使用。

    suspend() 和 resume() 方法配套使用。

     

     

     

    展开全文
  • 如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞,可以中断线程,并且通过抛出InterruptedException来唤醒它;如果线程遇到了IO阻塞,无能为力,因为IO是操作系统实现的,Java代码并没有办法直接...

    如果线程是因为调用了wait()sleep()或者join()方法而导致的阻塞,可以中断线程,并且通过抛出InterruptedException来唤醒它;如果线程遇到了IO阻塞,无能为力,因为IO是操作系统实现的,Java代码并没有办法直接接触到操作系统。以下是详细的唤醒方法:

    1. sleep() 方法:

    sleep(毫秒),指定以毫秒为单位的时间,使线程在该时间内进入线程阻塞状态,期间得不到cpu的时间片,等到时间过去了,线程重新进入可执行状态。(暂停线程,不会释放锁)

    2.suspend() resume() 方法:

    挂起和唤醒线程,suspend e()使线程进入阻塞状态,只有对应的resume e()被调用的时候,线程才会进入可执行状态。(不建议用,容易发生死锁)

    3. yield() 方法:

    会使的线程放弃当前分得的cpu时间片,但此时线程任然处于可执行状态,随时可以再次分得cpu时间片。yield()方法只能使同优先级的线程有执行的机会。调用 yield()的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。(暂停当前正在执行的线程,并执行其他线程,且让出的时间不可知)

    4.wait() notify() 方法:

    两个方法搭配使用,wait()使线程进入阻塞状态,调用notify()时,线程进入可执行状态。wait()内可加或不加参数,加参数时是以毫秒为单位,当到了指定时间或调用notify()方法时,进入可执行状态。(属于Object类,而不属于Thread类,wait()会先释放锁住的对象,然后再执行等待的动作。由于wait()所等待的对象必须先锁住,因此,它只能用在同步化程序段或者同步化方法内,否则,会抛出异常IllegalMonitorStateException.

    5.join()方法:

    也叫线程加入。是当前线程A调用另一个线程Bjoin()方法,当前线程转A入阻塞状态,直到线程B运行结束,线程A才由阻塞状态转为可执行状态。

    以上是Java线程唤醒和阻塞的五种常用方法,不同的方法有不同的特点,其中wait() notify()是其中功能最强大、使用最灵活的方法,但这也导致了它们效率较低、较容易出错的特性,因此,在实际应用中应灵活运用各种方法,以达到期望的目的与效果!


    展开全文
  • 如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞,可以中断线程,并且通过抛出InterruptedException来唤醒它;如果线程遇到了IO阻塞,无能为力,因为IO是操作系统实现的,Java代码并没有办法直接...
  • 线程run1在运行过程中通过检测状态量mbAcceptKeyFrames_是否为true来判定线程run2是否已经处理其事务完毕(或者说是空闲状态,处于挂起状态)。 若检测到run2处于空闲状态,则设置状态量insertNewKeyframe为
  • Java线程等待唤醒机制(加深理解)

    万次阅读 多人点赞 2019-08-04 16:28:06
    今天看源码的时候遇到这样一个场景,某...下面代码是一个简单的线程唤醒机制示例,主要就是在Activity启动的时候初始化并start线程,线程start后会进入等待状态,在onResume方法中执行notify方法唤醒线程。通过这样...
  • C++大量线程等待与唤醒

    千次阅读 2020-06-20 18:01:36
    一、线程唤醒方法 C++11之后提供了thread线程类,可以很方便的编写多线程程序。线程的等待和唤醒使用条件变量condition_variable和锁mutex结合实现,其中条件变量提供了wait(), notify(), notifyAll()等方法。 wait...
  • Java多线程线程虚假唤醒

    千次阅读 2019-05-12 20:35:37
    Java多线程线程虚假唤醒 本文目录提纲 问题:两个线程对一个初始值为零的变量操作,实现一个线程加一,另一个线程减一,来十次。 问题:两个线程对一个初始值为零的变量操作,实现一个线程加一,另一个线程...
  • 线程沉睡(sleep)并不会让线程释放它所持有的同步锁,而且在这期间也不会阻碍其他线程的运行...线程唤醒线程唤醒可以使得执行了sleep操作的线程或执行了wait操作或者join操作的线程唤醒。线程沉睡要指定沉睡的时间,如
  • java 线程睡眠唤醒 Java睡眠线程 (Java Sleeping Thread) To sleep a thread for a specified time, Java provides sleep method which is defined in Thread class. The sleep method is an overloaded method ...
  • 线程虚假唤醒指的是, 本以为满足了唤醒条件, 然后将阻塞的线程唤醒, 但是在开始执行逻辑时, 却不满足唤醒条件. 1.1 Product 类 新建两个方法sale()和 purchase(), 需要使用synchronized 关键字修饰 使用this....
  • 线程之Java线程阻塞与唤醒

    万次阅读 2014-12-06 18:58:01
    线程的阻塞和唤醒在多线程并发过程中是一个关键点,当线程数量达到很大的数量级时,并发可能带来很多隐蔽的问题。如何正确暂停一个线程,暂停后又如何在一个要求的时间点恢复,这些都需要仔细考虑的细节。在Java发展...
  • 线程A有两种方式唤醒线程B: 1. condition variable, 即线程B wait一个condition variable, 而线程A负责对这个co ndition调用notify()来唤醒线程B 2. 利用pipe,线程B拥有pipe的读端,线程A拥有pipe的写端。 在任务...
  • 线程唤醒interrupt()方法: 如果一个线程睡眠太久了,有没有办法唤醒它吗? 有的,使用"对象.interrupt()"方法。 这个方法的意思是:中断打扰,一盆冷水过去,线程立马醒了,够形象。 唤醒的机制是靠异常机制,当...
  • 线程之伪唤醒

    千次阅读 2019-12-09 20:55:20
    近期学习java多线程遇到伪唤醒这一新鲜的词汇,伪唤醒是什么?为什么会造成伪唤醒?接下来就以经典的生产者消费者模式为例阐述一下。
  • 线程唤醒机制

    千次阅读 2019-08-06 15:41:30
    线程的状态 1、new新建状态:线程刚被创建,但是没有启动,还没有调用start方法 2、Runable可运行状态:线程可以在JVM中运行,即抢夺到CPU的使用权 3、Blocked锁阻塞状态:当一个线程试图获取一个对象锁时,但是该...
  • 线程wait等待和notify唤醒

    千次阅读 2012-04-11 16:48:52
    /**  * 测试wait和notify方法 ... * 等待是当前线程对对象等待,唤醒是线程对等待对象的所有线程唤醒(可随机唤醒一个,可唤醒所有的)  * @author sam 2012-4-11  */ public class TestWai
  • 线程等待与唤醒

    2018-03-23 17:05:19
    线程等待与唤醒 标签: 多线程 基本方法简介 所有的等待和唤醒线程,都是针对某个具体对象实例的. API接口 说明 wait() 让当前线程进入等待(阻塞)状态,直到其他线程调用此对象的notify()或...
  • 什么是线程虚假唤醒

    2012-02-24 00:26:20
    JAVA文档上有提到线程虚假唤醒的概念,但是解释的不是明了 请问如何理解线程虚假唤醒?在什么情况下会发生?
  • 三个方法 wait() notify() notifyAll() 三个方法都使用在同步中,因为要对持有锁(又叫监控)的线程操作。...只有同一个锁上的被等待的线程,可以被同一个锁上的notify唤醒,不可以对不同锁中的线程进行唤醒
  • java线程阻塞唤醒的四种方式

    万次阅读 2018-03-07 17:49:05
    java在多线程情况下,经常会使用到线程的阻塞与唤醒,这里就为大家简单介绍一下以下几种阻塞/唤醒方式与区别,不做详细的介绍与代码分析 suspend与resume Java废弃 suspend() 去挂起线程的原因,是因为 suspend...
  • 线程阻塞与唤醒

    千次阅读 2017-07-17 16:44:20
    线程阻塞与唤醒的方法如图: package newThread;import java.util.Scanner;public class Twothread implements Runnable { private int i; @Override public void run() { //run方法同样是线程执行体 for(;i...
  • 唤醒指定线程

    千次阅读 2019-05-28 09:59:32
    一、简单 俗话说,没有比较就没有伤害。...在没有LockSupport之前,线程的挂起和唤醒咱们都是通过Object的wait和notify/notifyAll方法实现。 写一段例子代码,线程A执行一段业务逻辑后调用wait阻...
  • 唤醒下一个运行线程 } 子线程实现如下: void subThreadProcess(void) { while { do something } } 在主线程中只能访问到子线程的接口subThreadProcess,无法知道其内部实现。 ...
  • 线程等待,线程唤醒 “锁“中的主要方法 wait(): 让线程处于冻结状态,被wait的线程会被存储到线程池中。 notify():唤醒线程池中一个线程(任意),没有顺序。 notifyAll():唤醒线程池中的所有线程。 因为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 203,182
精华内容 81,272
关键字:

线程唤醒