精华内容
下载资源
问答
  • java多线程wait方法

    2019-12-06 22:21:40
    其实wait()方法就是使线程停止运行。 方法wait()的作用是使当前执行代码的线程进行等待,wait()方法是Object类的方法,该方法是用来将当前线程 置入“预执行队列”中,并且在wait()所在的代码处停止执行,直到接到...

    其实wait()方法就是使线程停止运行。

    1. 方法wait()的作用是使当前执行代码的线程进行等待,wait()方法是Object类的方法,该方法是用来将当前线程
      置入“预执行队列”中,并且在wait()所在的代码处停止执行,直到接到通知或被中断为止。
    2. wait()方法只能在同步方法中或同步块中调用。如果调用wait()时,没有持有适当的锁,会抛出异常。
    3. wait()方法执行后,当前线程释放锁,线程与其它线程竞争重新获取锁
      范例:观察wait()方法使用
    public static void main(String[] args) throws InterruptedException {
    Object object = new Object();
    synchronized (object) {
    System.out.println("等待中...");
    object.wait();
    System.out.println("等待已过...");
    }
    System.out.println("main方法结束...");
    }
    

    这样在执行到object.wait()之后就一直等待下去,那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了
    另外一个方法唤醒的方法notify()。

    object.wait();
    wait是 锁的对象 进行wait
    wait和sleep的比较:

    1. wait 之前需要请求锁,而wait执行时会先释放锁,等被唤醒时再重新请求锁。这个锁是 wait 对像上的 monitor lock
    2. sleep 是无视锁的存在的,即之前请求的锁不会释放,没有锁也不会请求。
    3. wait 是 Object 的方法
    4. sleep 是 Thread 的静态方法
    展开全文
  • Java多线程wait与synchronized方法     两种wait()方法   第一种需要一个以毫秒计的时间作参数,它的意思和sleep()一样,都是:“暂停一段时间”区别在于: 1.wait()会释放对象的锁,...

    两种wait()方法

     

    第一种需要一个以毫秒计的时间作参数,它的意思和sleep()一样,都是:“暂停一段时间”区别在于:

    1.wait()会释放对象的锁,也就是说在线程wait()期间,别的线程可以调用它的synchronized方法。

     线程sleep()的时候,不会释放对象的锁。当对wait中的线程调用interrupt时,会先重新获取对象的锁,再抛出InterruptedException。获取对象锁定之前,并无法抛出InterruptedException异常。

    2.除了时间到,wait()还可以用notify()或notifyAll()中止.

     

    第二种wait()不需要任何参数,它的用途更广.线程调用了这种wait()之后,会一直等下去,直到有别的线程调用了这个对象notify()或notifyAll().

     

    wait()方法的使用

     

    使用wait()方法时,线程便进入waitset,假设现在已经执行一个如下的语句:

    obj.wait();

    则目前的线程会暂时停止执行,进入实例obj的waitset。这个操作称为:线程在obj上wait。

    如果实例方法含有如下的语句时:

    wait();

    则其意义同:

    this.wait();

    故执行wait()的线程就会进入this的waitset。此时,就变成了线程在this上wait。

     

    和sleep()属于Thread类的方法不同,wait()、notify()和notifyAll()是根object的方法。虽然这种做法(把专为多线程服务的方法放到通用的根类里面)看上去有些奇怪,但却是必要的。因为它们所操控的是每个对象都会有的锁。所以结论就是,你只能在synchronized方法或synchronized段里调用wait(),notify(),notifyAll(),否则程序运行时会抛出IllegalMonitorStateException。这个异常带着一个挺让人费解的“currentthread notowner”消息。这个消息的意思是,如果线程调用对象的wait(),notify(),notifyAll(),必须先拥有这个对象的锁。

    调用notify()、notifyAll()方法后,被唤醒的唯一一个线程执行的第一条语句,是紧跟在wait()方法后面的语句。

     

    synchronized方法

     

    synchronized void f() { }

    synchronized void g(){ }

    每个对象都有一个锁(也称监控器monitor),它是对象生来就有的东西(因此你不必为此写任何代码)。当你调用synchronized方法时,这个对象就被锁住了。在方法返回并且解锁之前,谁也不能调用同一个对象的其它synchronized方法。

    线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时,这个对象的所有同步方法都被锁定了,在此期间,其他任何线程都不能访问这个对象的任意一个同步方法,直到这个线程执行完它所调用的同步方法并从中退出,从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后,其他线程是可以访问这个对象的所有非同步方法的。

    如果你调用了f( ),那么在f()返回并且解锁之前,你是不能调用同一个对象的g()的只要有实例就会相对有一个锁定,不是说因为某个实例的synchronized方法正在执行中,导致无法执行其他实例的synchronized方法。

    synchronized方法和synchronized块,无论碰到return或是异常,都会解除锁定。

    要调用synchronized实例方法的线程,一定要先获取this的锁定。一个实例的锁定,同一时间内只能有一个线程可以得到。

    如果实例不同,那锁定也不同了。如果有多个相异实例,那多个线程仍然可以分别执行不同实例的synchronized方法。

    使用synchronized块的时候,特别需要考虑“获取谁的锁定来保护”的情况。因为synchronized块需要明确的指出要获取的是哪个对象的锁定。例如:

    synchronized (obj){

    ………….

    }

    展开全文
  • Java多线程里的wait()方法,使用以后会使调用该方法的线程进入线程池,进入等待状态,和sleep()方法不同,wait()方法需要在synchronized关键字内使用,而且会使当前线程放开锁,让其他线程获得锁。 线程进入等待状态...

    Java多线程里的wait()方法,使用以后会使调用该方法的线程进入线程池,进入等待状态,和sleep()方法不同,wait()方法需要在synchronized关键字内使用,而且会使当前线程放开锁,让其他线程获得锁。

    线程进入等待状态后,我们想要唤醒线程的话需要使用获得锁的对象去调用notify()或notifyAll()方法来唤醒线程,而且同样是需要在synchronized关键字内使用。
    notify()方法是随机唤醒一个线程去获得锁,notifyAll()方法是唤醒所有线程去争抢锁

    线程执行内容

    public class Wait2 {
        private Object ob; //获得锁的对象
    
        public Wait2(Object ob) {
            this.ob = ob;
        }
    
        public void name() {
            synchronized (ob) {  //对象ob在此处获得锁
                for (int i = 1; i <= 10; i++) {
                    System.out.println(i);
                    if (i == 5) {
                        try {
                            System.out.println(Thread.currentThread().getName()+"线程等待中");
                            ob.wait();       //使当前线程进入等待状态
                            System.out.println(Thread.currentThread().getName()+"线程已唤醒");
                            try {
                                System.out.println("睡眠5秒后执行剩余部分");
                                TimeUnit.SECONDS.sleep(5);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    

    线程建立和开启

    public class Wait1 {
        public static void main(String[] args) {
            Object ob = new Object();
            Wait2 w2 = new Wait2(ob);  //给获得锁的对象赋值
            new Thread(() -> {
                w2.name();
            },"t1").start();  //t1线程开启
            new Thread(() -> {
                w2.name();
            },"t2").start();  //t2线程开启
            synchronized (ob) {
                ob.notifyAll();     //唤醒所有线程
            }
        }
    }
    

    执行结果
    通常情况下,加锁的线程在加锁内容读完前其他线程是无法获得锁的,但是从结果可以发现,t1线程进入等待状态后,加锁内容并没有执行完,t2线程就获得了锁开始执行,所以wait()方法确实是放开了锁的
    在这里插入图片描述

    展开全文
  • 关于线程wait方法

    千次阅读 2015-03-16 17:36:50
    今天遇到疑问,为什么如上图的线程不能唤醒wait。于是去CSDN提问和自己查资料,原来我这里只有一个线程,这里应该至少有两个同步的线程。于是我把代码改成这样。 这样,线程0就可以被唤醒。执行完。 那我...

    今天遇到疑问,为什么如上图的线程不能唤醒wait。于是去CSDN提问和自己查资料,原来我这里只有一个线程,这里应该至少有两个同步的线程。于是我把代码改成这样。

    这样,线程0就可以被唤醒。执行完。


    那我这里是把线程1延迟了三秒钟,如果不延迟,也能得到线程0唤醒,不过估计你要多刷几遍了。

    那这里线程1延迟三秒起到三秒作用了呢?

    其实就是在等待线程0走到“我要暂停了...”这一步,让线程0处于执行wait()后的状态--阻塞态。     因为这里循环的次数只有300次,以计算机的计算速度,很多时候在你还没有执行到wait的时候,就循环完300次了。这样,然后它再去wait(),其实这时候线程1已经执行完毕,只剩线程0和main守护线程,线程0也就不能被唤醒了。

    这里打印出当前线程是:线程0

    之后我又做了这样的试验。

    在线程0里去唤醒线程0,你们觉得可以吗?

    事实上是可以的。那其实这时候,sleep(3000)就没有什么意义了。但是这里同样需要线程0在线程1执行完之前走到wait方法,那其实这里又引发了一个疑问,这时候线程1都已经完成了,并且notify方法是在线程0里执行的,它是怎么跳转过去的?

    所以这里我觉得线程0并不是由线程1唤醒,而且从notify的前缀就能看出来,是我们同步锁的对象。wait()只是把线程0无限阻塞,等待唤醒,等线程1执行完毕,释放对象锁,然后线程0由对象唤醒,由阻塞态-->就绪态-->运行态。     当然这一切都不能少了两个线程,至少需要两个同步的线程。

    不知道我的想法对不对。欢迎指正

    展开全文
  • 最主要是sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法(锁代码块和方法锁)。 wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方...
  • sleep方法会使线程暂停执行一段时间,wait方法会阻塞线程,直到被唤醒或等待时间超时。  两者区别具体如下:  1 原理不同  sleep方法是Thread类的静态方法,使线程暂停执行一段时间,等到计时结束,该线程会...
  • 方法wait()的作用是让当前执行代码的线程进行等待,wait()方法是object类的方法,该方法用来将当前的线程置入“预执行队列”中,并且在wait()所在的代码行处停止执行,直到接到通知或者被中断为止。在调用wait()之前...
  • wait():等待,如果线程执行了wait方法,那么该线程会进入等待的状态,等待状态下的线程必须要被其他线程调用notify()方法才能唤醒。 notify():唤醒,唤醒线程池等待线程其中的一个。 notifyAll():唤醒线程池...
  • Java多线程wait()方法注意事项

    千次阅读 2019-05-02 11:40:38
    注意事项一: 当前线程调用共享对象的wait()方法时,当前线程只会释放当前共享对象的锁,当前线程持有的其他共享对象的监视器锁并不会被释放。 下面举个栗子: private static volatile Object resourceA = new ...
  • 1. 他们都是在多线程的环境下,都可以在程序的调用处阻塞指定的毫秒数,并返回。 2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ,从而使线程立刻抛出InterruptedException。 如果线程A希望立即...
  • // 不知道什么时候生产者回来添加产品,所以用一个随机时间来让进行线程随眠,来模仿生产者来访的不定时 Thread.sleep((int) (Math.random() * 10) * 100); } catch (InterruptedException e) { e.printStackTrace...
  • 多线程 wait notify

    2019-09-18 21:39:33
    多线程线程(wait、notify) *************************** 相关方法 public class Object { *************************** 线程唤醒 @HotSpotIntrinsicCandidate public final native void notify(); @...
  • 多线程安全 wait、notify方法
  • 多线程wait()与notify()和notifyAll()方法的总结 wait和sleep的区别 在调用wait方法时,线程必须持有调用对象的锁,当调用wait方法后,线程就会释放掉改对象的锁(monitor)。 在调用wait方法时,线程必须持有调用...
  • 在前面介绍了线程入门、线程安全、线程的一些琐碎的知识点,现在我们讲讲如何让线程变得听话,指挥线程执行。 wait notfiy 首先声明一点wait( ),notify( ),notifyAll( )都不属于Thread类,而是属于Object基础类...
  • 多线程wait/notify

    2020-04-30 18:22:40
    Object类中关于等待/唤醒的API详细信息如下: 方法 ... 让当前线程处于等待(阻塞)状态,直到其它线程调用此对象的notify()或notifyAll()方法,当前线程被唤醒(进入就绪状态)。 wait(long...
  • 本示例实现生产者和消费者是用wait()和notifyAll()方法,这两个方法的使用比之前的suspend()和resume()方法的优势是 在synchronized方法包围的时候会释放锁,不会造成死锁。 缺点如果在一个方法中先执行notifyAll()...
  • 多线程 wait和sleep区别

    2017-11-21 18:44:00
    他们都是在多线程的环境下,都可以在程序的调用处阻塞指定的毫秒数,并返回。2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ,从而使线程立刻抛出InterruptedException。 如果线程A希望立即结束...
  • wait方法可以中断线程的执行,使本线程等待,让出cpu资源,使其他线程得到该资源运行。 如果这时使用**notify()**方法,则通知该线程结束等待(注意:notify的作用相当于叫醒睡着的人,而并不会给他分配任务,就是说...
  • 在java多线程情况下,当线程被wait后,又通过notify方法唤醒时,在if情况下被唤醒,程序从哪里wait的就从哪里继续执行,在while的情况下被唤醒,程序依旧会从哪里wait的继续往下执行,但是,在执行之前会先对循环...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,498
精华内容 2,199
关键字:

多线程wait方法