（转）wait和sleep的区别 以及 实例演示

http://blog.csdn.net/yang_hui1986527/article/details/7745749

 

 在多线程编程中，经常会使用sleep与wait操作，我们理解sleep与wait的最大区别是sleep等待是不会释放当前锁，而wait则反之。我今天想到一个现实例子来比较这两者的区别。
  我以去火车站买票的例子来说明。我们去火车站买票，当站到售票窗口前要告诉售票员需要到哪里的票，什么时候发车的，售票员就通过电脑去给我们打印票，这个时候我们就得等待。如果我们用sleep模式，就得一直站在那里等，直到售票员给我们票;如果用wait模式，这个时候就离开我们所站的位置，后面的票友就可能站到我当前的位置（窗口前），我们要取票的话，就得重新排在队伍后面去取票。

  这是我今天想到的一个例子来帮助大家理解，欢迎大家拍砖!

 

参考：

Java多线程中Sleep与Wait的区别  http://uule.iteye.com/blog/1106710
关于多线程的wait与sleep的区别  http://www.iteye.com/topic/414054


有关于wait和sleep的区别，请先拜读以上文章。上面已经讲的很清楚了。

这里我主要根据自己的理解，在实例中运用wait和sleep，以加深对两者之间一个关键区别的理解。（wait会释放对象锁，而sleep则不会释放对象锁。）


实例主要流程：

Wait：

Sync_Wait 线程运行到i=20的时候，调用wait等待。此时mObject对象锁已经释放，Sync_Wait_Normal开始运行。

当Sync_Wait_Normal运行到i=50时，调用mObject.notify();唤醒了Sync_Wait。但由于此时，Sync_Wait无法得到mObject对象锁而无法立即运行。

等到Sync_Wait_Normal运行到i=80时，调用wait，Sync_Wait_Normal开始进行线程等待，并释放mObject对象锁。

这时，Sync_Wait 进行运行（从i=21开始）。当Sync_Wait 运行到i=50时，调用mObject.notify();唤醒了Sync_Wait_Normal。但由于此时，Sync_Wait_Normal无法得到mObject对象锁而无法立即运行。所以，一直到Sync_Wait运行到i=99，也就是Sync_Wait运行结束后，释放mObject对象锁。这个时候，Sync_Wait_Normal才继续运行到最后。


Sleep：

Sync_Sleep线程运行到i=20时，调用Thread.sleep，使得Sync_Sleep休眠2秒钟。但由于此时sleep并没有释放mObject对象锁。因此，Sync_Sleep_Normal此时也无法获得mObject对象锁而运行。等到Sync_Sleep因为sleep的时间过来，自己醒来，并运行结束后，Sync_Sleep_Normal才从头开始运行，一直到结束。

所以，整个过程就会使这样的：Sync_Sleep运行到i=20，在此等待2秒（会出现停顿2s现象）。接着继续运行到i=99，Sync_Sleep运行完成并结束，释放mObject对象锁。接着，Sync_Sleep_Normal获得mObject对象锁，从头开始运行，一直到结束。


实例源码下载：http://download.csdn.net/detail/yang_hui1986527/4429503


MainActivity.java

[java] view plaincopyprint?
  1. package com.snowdream.demo;  
  2.   
  3. import java.util.concurrent.ExecutorService;  
  4. import java.util.concurrent.Executors;  
  5.   
  6. import android.app.Activity;  
  7. import android.os.Bundle;  
  8. import android.os.Handler;  
  9. import android.os.Message;  
  10. import android.text.TextUtils;  
  11. import android.util.Log;  
  12. import android.view.Menu;  
  13. import android.view.View;  
  14. import android.widget.TextView;  
  15.   
  16. public class MainActivity extends Activity {  
  17.   
  18.     private static final int MSG_CLEAR = 0;  
  19.     private static final int MSG_UPDATE = 1;  
  20.   
  21.     private final Object mObject = new Object();  
  22.     private final String tag = "MainActivity";  
  23.     ExecutorService pool = null;   
  24.   
  25.     private static TextView mTextView = null;  
  26.   
  27.     private static Handler mHandler = new Handler(){  
  28.         public void handleMessage(Message msg){  
  29.             switch (msg.what) {  
  30.             case MSG_CLEAR:  
  31.                 mTextView.setText("");  
  32.                 break;  
  33.             case MSG_UPDATE:  
  34.                 String str = (String)msg.obj;  
  35.                 if (!TextUtils.isEmpty(str)) {  
  36.                     mTextView.append(str);  
  37.                     mTextView.append("\n");  
  38.                 }  
  39.                 break;  
  40.             default:  
  41.                 break;  
  42.             }  
  43.         };  
  44.     };  
  45.   
  46.   
  47.     @Override  
  48.     public void onCreate(Bundle savedInstanceState) {  
  49.         super.onCreate(savedInstanceState);  
  50.         setContentView(R.layout.activity_main);  
  51.         initView();  
  52.         initData();  
  53.     }  
  54.   
  55.   
  56.     private void initView() {  
  57.         mTextView = (TextView)findViewById(R.id.textView1);  
  58.     }  
  59.   
  60.     private void initData() {  
  61.         pool = Executors.newFixedThreadPool(2);   
  62.     }  
  63.   
  64.   
  65.     @Override  
  66.     protected void onDestroy() {  
  67.         super.onDestroy();  
  68.         pool.shutdown();  
  69.     }  
  70.   
  71.     public void OnButton1Click(View view) {  
  72.         int id = view.getId();  
  73.         switch (id) {  
  74.         case R.id.button1:  
  75.             mHandler.sendMessage(mHandler.obtainMessage(MSG_CLEAR));  
  76.   
  77.             Sync_Wait sync_Wait = new Sync_Wait();  
  78.             Sync_Wait_Normal sync_Wait_Normal = new Sync_Wait_Normal();  
  79.             pool.execute(sync_Wait);  
  80.             pool.execute(sync_Wait_Normal);  
  81.             break;  
  82.         case R.id.button2:  
  83.             mHandler.sendMessage(mHandler.obtainMessage(MSG_CLEAR));  
  84.   
  85.             Sync_Sleep sync_Sleep  = new Sync_Sleep();  
  86.             Sync_Sleep_Normal sync_Sleep_Normal = new Sync_Sleep_Normal();  
  87.             pool.execute(sync_Sleep);  
  88.             pool.execute(sync_Sleep_Normal);      
  89.             break;  
  90.         default:  
  91.             break;  
  92.         }  
  93.     }  
  94.   
  95.     public class Sync_Wait implements Runnable {  
  96.         public void run() {  
  97.             synchronized(mObject){  
  98.                 for (int i = 0; i < 100; i++) {  
  99.                     Log.i(tag, "Sync_Wait: "+ i);  
  100.   
  101.                     mHandler.sendMessage(mHandler.obtainMessage(MSG_UPDATE, "Sync_Wait: "+ i));  
  102.   
  103.                     if (20 == i) {  
  104.                         try {  
  105.                             mObject.wait();  
  106.                         } catch (InterruptedException e) {  
  107.                             // TODO Auto-generated catch block  
  108.                             e.printStackTrace();  
  109.                         }  
  110.                     }  
  111.                       
  112.                     if (50 == i) {  
  113.                         mObject.notify();  
  114.                     }  
  115.   
  116.                 }  
  117.             }     
  118.         }  
  119.     }   
  120.   
  121.   
  122.     public class Sync_Sleep implements Runnable {  
  123.         public void run() {  
  124.             synchronized(mObject){  
  125.                 for (int i = 0; i < 100; i++) {  
  126.                     Log.i(tag, "Sync_Sleep_Normal: "+ i);  
  127.   
  128.                     mHandler.sendMessage(mHandler.obtainMessage(MSG_UPDATE,  "Sync1_Sleep: "+ i));  
  129.   
  130.                     if (20 == i) {  
  131.                         try {  
  132.                             Thread.sleep(2000);  
  133.                         } catch (InterruptedException e) {  
  134.                             // TODO Auto-generated catch block  
  135.                             e.printStackTrace();  
  136.                         }     
  137.                     }  
  138.                 }  
  139.             }  
  140.         }  
  141.     }   
  142.   
  143.   
  144.     public class Sync_Sleep_Normal implements Runnable {  
  145.         public void run() {  
  146.             synchronized(mObject){  
  147.                 for (int i = 0; i < 100; i++) {  
  148.                     Log.i(tag, "Sync_Sleep_Normal: "+ i);  
  149.   
  150.                     mHandler.sendMessage(mHandler.obtainMessage(MSG_UPDATE, "Sync_Sleep_Normal: "+ i));  
  151.                 }  
  152.             }     
  153.         }  
  154.     }   
  155.   
  156.     public class Sync_Wait_Normal implements Runnable {  
  157.         public void run() {  
  158.             synchronized(mObject){  
  159.                 for (int i = 0; i < 100; i++) {  
  160.                     Log.i(tag, "Sync_Normal: "+ i);  
  161.   
  162.                     mHandler.sendMessage(mHandler.obtainMessage(MSG_UPDATE, "Sync_Wait_Normal: "+ i));  
  163.   
  164.                     if (50 == i) {  
  165.                         mObject.notify();  
  166.                     }  
  167.                       
  168.                     if (80 == i) {  
  169.                         try {  
  170.                             mObject.wait();  
  171.                         } catch (InterruptedException e) {  
  172.                             // TODO Auto-generated catch block  
  173.                             e.printStackTrace();  
  174.                         }  
  175.                     }  
  176.                       
  177.                 }  
  178.             }     
  179.         }  
  180.     }   
  181.   
  182.     @Override  
  183.     public boolean onCreateOptionsMenu(Menu menu) {  
  184.         getMenuInflater().inflate(R.menu.activity_main, menu);  
  185.         return true;  
  186.     }  
  187. }  

activity_main.xml

[html] view plaincopyprint?
  1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  2.     xmlns:tools="http://schemas.android.com/tools"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent" >  
  5.   
  6.     <LinearLayout  
  7.         android:id="@+id/linearLayout1"  
  8.         android:layout_width="match_parent"  
  9.         android:layout_height="wrap_content"  
  10.         android:layout_alignParentTop="true" >  
  11.   
  12.         <Button  
  13.             android:id="@+id/button1"  
  14.             android:layout_width="0dp"  
  15.             android:layout_height="wrap_content"  
  16.             android:layout_weight="1"  
  17.             android:gravity="center"  
  18.             android:onClick="OnButton1Click"  
  19.             android:text="Wait" />  
  20.   
  21.         <Button  
  22.             android:id="@+id/button2"  
  23.             android:layout_width="0dp"  
  24.             android:layout_height="wrap_content"  
  25.             android:layout_weight="1"  
  26.             android:gravity="center"  
  27.             android:onClick="OnButton1Click"  
  28.             android:text="Sleep" />  
  29.          
  30.     </LinearLayout>  
  31.   
  32.     <ScrollView  
  33.         android:id="@+id/scrollView1"  
  34.         android:layout_width="match_parent"  
  35.         android:layout_height="match_parent"  
  36.         android:layout_below="@+id/linearLayout1"  
  37.         android:layout_toLeftOf="@+id/textView1" >  
  38.   
  39.         <TextView  
  40.             android:id="@+id/textView1"  
  41.             android:layout_width="wrap_content"  
  42.             android:layout_height="wrap_content"  
  43.             android:padding="@dimen/padding_small"  
  44.             tools:context=".MainActivity" />  
  45.     </ScrollView>  
  46.   
  47. </RelativeLayout>  
效果预览：


posted @ 2012-07-29 19:12  汀州の夜  阅读(258)  评论(0)  编辑  收藏  举报