码迷,mamicode.com
首页 > 其他好文 > 详细

Wait,Notify,Sleep 区别 新手看

时间:2016-06-15 22:10:53      阅读:237      评论:0      收藏:0      [点我收藏+]

标签:

来自百度文库

 

 

java中的wait()notify()使用实例

 

本例子实现了两个线程,每个线程输出1100的数字。

第一个线程输出1-10,停止,通知第二个线程 输出1-10 第二个线程停止 通知第一个线程 输出11-20 ...

实现的要点是在Java中,每个对象都有个对象锁标志(Object lock flag)与之想关联,当一个线程A调用对象的一段synchronized代码时,

它首先要获取与这个对象关联的对象锁标志,然后执行相应的代码,执行结束后,把这个对象锁标志返回给对象;因此,在线程A执行

synchronized代码期间,如果另一个线程B也要执行同一对象的一段synchronized代码时(不一定与线程A执行的相同),它将

要等到线程A执行完后,才能继续....

 

如何利用wait() notify() notifyAll()?

 

synchronized代码被执行期间,线程可以调用对象的wait()方法,释放对象锁标志,进入等待状态,并且可以调用notify()或者

notifyAll()方法通知正在等待的其他线程。notify()通知等待队列中的第一个线程,notifyAll()通知的是等待队列中的所有线程。

 

 

 

package jdeveloper.study;

 

 

import java.lang.Runnable;

import java.lang.Thread;

 

public class DemoThread implements Runnable{

 

public DemoThread() {

      TestThread testthread1 = new TestThread(this,"1");

      TestThread testthread2 = new TestThread(this,"2");

 

      testthread2.start();

      testthread1.start();

 

 

}

 

public static void main(String[] args) {

  DemoThread demoThread1 = new DemoThread();

 

}

 

 

  public void run(){

 

    TestThread t = (TestThread) Thread.currentThread();

    try{

      if (!t.getName().equalsIgnoreCase("1")) {

        synchronized(this) {

            wait();

        }

      }

      while(true){

 

        System.out.println("@time in thread"+ t.getName()+ "="+ t.increaseTime());

 

        if(t.getTime()%10 == 0) {

        synchronized(this) {

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

          notify();

          if ( t.getTime()==100 ) break;

          wait();

        }

      }

    }

    }catch(Exception e){e.printStackTrace();}

  }

 

}

 

class TestThread extends Thread{

  private int time = 0 ;

  public TestThread(Runnable r,String name){

    super(r,name);

  }

  public int getTime(){

    return time;

  }

  public int increaseTime (){

    return ++time;

  }

 

 

}

 

 

 

 

 

 

Java的线路同步示例(synchronizedwaitnotify

从网上找到的代码(随便改的)。比较清晰地展示了waitnotify的运行机制。

 

package com.wubuku.mytest;

 

public class ThreadingExample {

 

    public static void main(String args[]) {

        Thread[] threads = new Thread[2];

        for (int count = 0; count < threads.length; count++) {

            threads[count] = new ThreadCounter(count);

            threads[count].start();

        }

    }

 

    private static class ThreadCounter extends Thread {

        /**

         * 在没有同步的情况下,这个方法会打印出不定顺序的数字

         */

        public static void count() {

            for (int count = 1; count <= 5; count++)

                System.out.print(count + " ");

        }

 

        public static Object synchronizeVariable = "locking variable";

 

        private int threadNo;

 

        public ThreadCounter(int threadNo) {

            this.threadNo = threadNo;

        }

 

        public void run() {

            countWithSync();

        }

 

        /**

         * 在有同步的情况下,能打印出这样顺序的数字: 1 1 2 2 3 3 4 4 5 5

         */

        private void countWithSync() {

            synchronized (synchronizeVariable) {

                for (int count = 1; count <= 5; count++) {

                    System.out.println("[thread_" + threadNo + " print:]"

                            + count + " ");

                    synchronizeVariable.notifyAll();

 

                    if (count < 5) {

                        System.out.println("[thread_" + threadNo

                                + " sleep zzz...] ");

 

                        try {

                            synchronizeVariable.wait();

                        } catch (InterruptedException error) {

                        }

 

                        System.out.println("[thread_" + threadNo + " wakup!] ");

                    }

                }

            }

 

        }

    }

}

 

 

 

一个理解wait()notify()的例子

 

  下面是我原来在CSDN论坛上看到的一个贴子,涉及到同步,wait(),notify()等概念的理解,我试着根据原来的一些回复和Think in Java上的相关概念将wait()notify()这两个方法剖析了一下,欢迎指教.

 

  问题如下:

 

//分析这段程序,并解释一下,着重讲讲synchronizedwait(),notify 谢谢!

class ThreadA

{

  public static void main(String[] args)

  {

    ThreadB b=new ThreadB();

    b.start();

    System.out.println("b is start....");

    synchronized(b)//括号里的b是什么意思,起什么作用?

    {

      try

      {

 System.out.println("Waiting for b to complete...");

 b.wait();//这一句是什么意思,究竟让谁wait?

        System.out.println("Completed.Now back to main thread");

      }catch (InterruptedException e){}

    }

    System.out.println("Total is :"+b.total);

   }

}

 

 

class ThreadB extends Thread

{

  int total;

  public void run()

  {

    synchronized(this)

    {

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

      for (int i=0;i<100;i++ )

      {

        total +=i;

        System.out.println("total is "+total);

      }

      notify();

    }

  }

}

 

  要分析这个程序,首先要理解notify()wait(),为什么在前几天纪录线程的时候没有纪录这两个方法呢,因为这两个方法本来就不属于 Thread,而是属于最底层的object基础类的,也就是说不光是Thread,每个对象都有notifywait的功能,为什么?因为他们是用来操纵锁的,而每个对象都有锁,锁是每个对象的基础,既然锁是基础的,那么操纵锁的方法当然也是最基础了.

 

  再往下看之前呢,首先最好复习一下Think in Java14.3.1中第3部分内容:等待和通知,也就是wait()notify.

 

  按照Think in Java中的解释:"wait()允许我们将线程置入“睡眠”状态,同时又“积极”地等待条件发生改变.而且只有在一个notify()notifyAll()发生变化的时候,线程才会被唤醒,并检查条件是否有变."

 

  我们来解释一下这句话.

  "wait()允许我们将线程置入“睡眠”状态",也就是说,wait也是让当前线程阻塞的,这一点和sleep或者suspend是相同的.那和sleep,suspend有什么区别呢?

 

  区别在于"(wait)同时又“积极”地等待条件发生改变",这一点很关键,sleepsuspend无法做到.因为我们有时候需要通过同步(synchronized)的帮助来防止线程之间的冲突,而一旦使用同步,就要锁定对象,也就是获取对象锁,其它要使用该对象锁的线程都只能排队等着, 等到同步方法或者同步块里的程序全部运行完才有机会.在同步方法和同步块中,无论sleep()还是suspend()都不可能自己被调用的时候解除锁定,他们都霸占着正在使用的对象锁不放.

  而wait却可以,它可以让同步方法或者同步块暂时放弃对象锁,而将它暂时让给其它需要对象锁的人(这里应该是程序块,或线程),这意味着可在执行wait()期间调用线程对象中的其他同步方法!在其它情况下(sleep,suspend),这是不可能的.

  但是注意我前面说的,只是暂时放弃对象锁,暂时给其它线程使用,wait所在的线程还是要把这个对象锁收回来的呀.wait什么?就是wait别人用完了还给我啊!

  好,那怎么把对象锁收回来呢?

  第一种方法,限定借出去的时间.wait()中设置参数,比如wait(1000),以毫秒为单位,就表明我只借出去1秒中,一秒钟之后,我自动收回.

  第二种方法,让借出去的人通知我,他用完了,要还给我了.这时,我马上就收回来.,假如我设了1小时之后收回,别人只用了半小时就完了,那怎么办呢?!当然用完了就收回了,还管我设的是多长时间啊.

 

  那么别人怎么通知我呢?相信大家都可以想到了,notify(),这就是最后一句话"而且只有在一个notify()notifyAll()发生变化的时候,线程才会被唤醒"的意思了.

  因此,我们可将一个wait()notify()置入任何同步方法或同步块内部,无论在那个类里是否准备进行涉及线程的处理。而且实际上,我们也只能在同步方法或者同步块里面调用wait()notify().

 

  这个时候我们来解释上面的程序,简直是易如反掌了.

 

  synchronized(b){...};的意思是定义一个同步块,使用b作为资源锁。b.wait();的意思是临时释放锁,并阻塞当前线程,好让其他使用同一把锁的线程有机会执行,在这里要用同一把锁的就是b线程本身.这个线程在执行到一定地方后用notify()通知wait的线程,锁已经用完,notify()所在的同步块运行完之后,wait所在的线程就可以继续执行

Wait,Notify,Sleep 区别 新手看

标签:

原文地址:http://www.cnblogs.com/kingkang/p/5588933.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!