Android游戏开发教程之十六:多线程的操作方式分享

Android游戏开发教程之十六:多线程的操作方式

  游戏开发与软件开发多线程的重要性

  如果程序主线程被阻塞超过5秒,系统会提示“应用程序无响应” 这就是ANR 。 ANR的全称是Application Not Responding,使用多线程可以避免ANR。但是这里要注意一下不要为了避免ANR而过多的使用多线程,除非万不得已的情况。 比如访问网络服务端返回的过慢、数据过多导致滑动屏幕不流畅、或者I/O读取过大的资源等等。这里可以开启一个新线程来处理这些耗时的操作。 如果过多使用多线程会出现数据同步的问题须要程序员去处理,所以使用多线程的时候尽量保持它的独立不会被其它线程干预。java语言提供了一个线程锁的概念 synchronized 可以添加对象锁与方法锁专门避免多线程同时访问一个方法或者一个对象导致的问题,有兴趣的朋友可以去看看这里我不罗嗦啦 。

  1.Thread与Handler执行多线程

Android游戏开发教程之十六:多线程的操作方式

  Handler主要用于程序主线程与我们自己创建的线程进行通信。在这个例子中点击按钮后创建一个新的线程去循环的加载100张图片每加载完一张图片在Thread中使用Handler发送消息通知UI线程更新显示,直到加在完毕通知UI显示加载完成一共耗时多少秒。可见Handler的重要性它就是主线程与我们自己创建的线程的桥梁啊~~~

Java代码
  1. import java.io.InputStream;  
  2.    
  3. import android.app.Activity;  
  4. import android.content.Context;  
  5. import android.graphics.Bitmap;  
  6. import android.graphics.BitmapFactory;  
  7. import android.os.Bundle;  
  8. import android.os.Handler;  
  9. import android.os.Message;  
  10. import android.view.View;  
  11. import android.view.View.OnClickListener;  
  12. import android.widget.Button;  
  13. import android.widget.TextView;  
  14.    
  15. public class SingleActivity extends Activity {  
  16.    
  17.     /**读取进度**/  
  18.     public final static int LOAD_PROGRESS = 0;   
  19.    
  20.     /**标志读取进度结束**/  
  21.     public final static int LOAD_COMPLETE = 1;   
  22.    
  23.     /** 开始加载100张图片按钮 **/  
  24.     Button mButton = null;  
  25.     /** 显示内容 **/  
  26.     TextView mTextView = null;  
  27.     /** 加载图片前的时间 **/  
  28.     Long mLoadStatr = 0L;  
  29.     /** 加载图片后的时间 **/  
  30.     Long mLoadEnd = 0L;  
  31.    
  32.     Context mContext = null;  
  33.    
  34.     //接收传递过来的信息  
  35.     Handler handler = new Handler() {  
  36.     @Override  
  37.     public void handleMessage(Message msg) {  
  38.         switch (msg.what) {  
  39.         case LOAD_PROGRESS:  
  40.         mTextView.setText("当前读取到第" + msg.arg1 + "张图片");  
  41.         break;  
  42.         case LOAD_COMPLETE:  
  43.         mTextView.setText("读取结束一共耗时" + msg.arg1 + "毫秒");  
  44.         break;  
  45.         }  
  46.         super.handleMessage(msg);  
  47.     }  
  48.     };  
  49.    
  50.     @Override  
  51.     protected void onCreate(Bundle savedInstanceState) {  
  52.     setContentView(R.layout.single);  
  53.     mContext = this;  
  54.    
  55.     /** 拿到button 与 TextView 对象 **/  
  56.     mButton = (Button) findViewById(R.id.button0);  
  57.     mTextView = (TextView) findViewById(R.id.textView0);  
  58.     mTextView.setText("点击按钮开始更新时间");  
  59.     mButton.setOnClickListener(new OnClickListener() {  
  60.         @Override  
  61.         public void onClick(View arg0) {  
  62.         //开始读取图片  
  63.         LoadImage();  
  64.         }  
  65.     });  
  66.    
  67.     super.onCreate(savedInstanceState);  
  68.     }  
  69.    
  70.     public void LoadImage() {  
  71.     new Thread() {  
  72.         @Override  
  73.         public void run() {  
  74.         //得到加载图片开始的时间  
  75.         mLoadStatr = System.currentTimeMillis();  
  76.    
  77.         for (int i = 0; i < 100; i++) {  
  78.             // 这里循环加载图片100遍  
  79.             ReadBitMap(mContext, R.drawable.bg);  
  80.    
  81.             // 每读取完一张图片将进度甩给handler  
  82.             Message msg = new Message();  
  83.             msg.what = LOAD_PROGRESS;  
  84.             msg.arg1 = i + 1;  
  85.             handler.sendMessage(msg);  
  86.         }  
  87.    
  88.         //得到加载图片结束的时间  
  89.         mLoadEnd = System.currentTimeMillis();  
  90.    
  91.         //100张图片加载完成  
  92.         Message msg = new Message();  
  93.         msg.what = LOAD_COMPLETE;  
  94.         msg.arg1 = (int) (mLoadEnd – mLoadStatr);  
  95.         handler.sendMessage(msg);  
  96.         }  
  97.     }.start();  
  98.    
  99.     }  
  100.    
  101.     /** 
  102.      * 读取本地资源的图片 
  103.      * 
  104.      * @param context 
  105.      * @param resId 
  106.      * @return 
  107.      */  
  108.     public Bitmap ReadBitMap(Context context, int resId) {  
  109.     BitmapFactory.Options opt = new BitmapFactory.Options();  
  110.     opt.inPreferredConfig = Bitmap.Config.RGB_565;  
  111.     opt.inPurgeable = true;  
  112.     opt.inInputShareable = true;  
  113.     // 获取资源图片  
  114.     InputStream is = context.getResources().openRawResource(resId);  
  115.     return BitmapFactory.decodeStream(is, null, opt);  
  116.     }  
  117. }  

  2.TimerTask与Handler延迟多线程

Android游戏开发教程之十六:多线程的操作方式

  Timer与TimerTask可以构建一个延迟器 就好比开启一个线程每隔一段规定的时间访问一次。可以在这个线程中去关闭这个Timer 与TimerTask ,举个例子比如现在我要做一个网游帐号登录超时客户端的检测 用户输入完帐号密码点击登录这时候我开启一个TimerTask每过1秒检查一下用户是否登录成功,过了10秒如果还没有登录成功提示他登陆超时。这个时候我就须要在这个检测线程中去关闭Timer 与TimerTask  因为不需要它在循环检测了。 调用cancel()就可以关闭,请同学们阅读下面这个例子。

Java代码
  1. import java.util.Timer;  
  2. import java.util.TimerTask;  
  3. import android.app.Activity;  
  4. import android.content.Context;  
  5. import android.os.Bundle;  
  6. import android.os.Handler;  
  7. import android.os.Message;  
  8. import android.view.View;  
  9. import android.view.View.OnClickListener;  
  10. import android.widget.Button;  
  11. import android.widget.TextView;  
  12.    
  13. public class TimerTaskActivity extends Activity {  
  14.    
  15.     /**执行Timer进度**/  
  16.     public final static int LOAD_PROGRESS = 0;   
  17.    
  18.     /**关闭Timer进度**/  
  19.     public final static int CLOSE_PROGRESS = 1;   
  20.    
  21.     /** 开始TimerTask按钮 **/  
  22.     Button mButton0 = null;  
  23.    
  24.     /** 关闭TimerTask按钮 **/  
  25.     Button mButton1 = null;  
  26.    
  27.     /** 显示内容 **/  
  28.     TextView mTextView = null;  
  29.    
  30.     Context mContext = null;  
  31.    
  32.     /**Timer对象**/  
  33.     Timer mTimer = null;  
  34.    
  35.     /**TimerTask对象**/  
  36.     TimerTask mTimerTask = null;  
  37.    
  38.     /**记录TimerID**/  
  39.     int mTimerID = 0;  
  40.    
  41.     /**接收传递过来的信息**/  
  42.     Handler handler = new Handler() {  
  43.     @Override  
  44.     public void handleMessage(Message msg) {  
  45.         switch (msg.what) {  
  46.         case LOAD_PROGRESS:  
  47.         mTextView.setText("当前TimerID为" + msg.arg1 );  
  48.         break;  
  49.         case CLOSE_PROGRESS:  
  50.         mTextView.setText("当前Timer已经关闭请重新开启" );  
  51.         break;  
  52.    
  53.         }  
  54.         super.handleMessage(msg);  
  55.     }  
  56.     };  
  57.    
  58.     @Override  
  59.     protected void onCreate(Bundle savedInstanceState) {  
  60.     setContentView(R.layout.timer);  
  61.     mContext = this;  
  62.    
  63.     /** 拿到button 与 TextView 对象 **/  
  64.     mButton0 = (Button) findViewById(R.id.button0);  
  65.     mButton1 = (Button) findViewById(R.id.button1);  
  66.     mTextView = (TextView) findViewById(R.id.textView0);  
  67.     mTextView.setText("点击按钮开始更新时间");  
  68.    
  69.     //开始  
  70.     mButton0.setOnClickListener(new OnClickListener() {  
  71.         @Override  
  72.         public void onClick(View arg0) {  
  73.         //开始执行timer  
  74.         StartTimer();  
  75.         }  
  76.     });  
  77.    
  78.     //关闭  
  79.     mButton1.setOnClickListener(new OnClickListener() {  
  80.         @Override  
  81.         public void onClick(View arg0) {  
  82.         //停止执行timer  
  83.         CloseTimer();  
  84.         }  
  85.     });  
  86.    
  87.     super.onCreate(savedInstanceState);  
  88.     }  
  89.    
  90.     public void StartTimer() {  
  91.    
  92.     if (mTimer == null) {  
  93.         mTimerTask = new TimerTask() {  
  94.         public void run() {  
  95.             //mTimerTask与mTimer执行的前提下每过1秒进一次这里  
  96.             mTimerID ++;  
  97.             Message msg = new Message();  
  98.             msg.what = LOAD_PROGRESS;  
  99.             msg.arg1 = (int) (mTimerID);  
  100.             handler.sendMessage(msg);  
  101.         }  
  102.         };  
  103.         mTimer = new Timer();  
  104.    
  105.         //第一个参数为执行的mTimerTask  
  106.         //第二个参数为延迟的时间 这里写1000的意思是mTimerTask将延迟1秒执行  
  107.         //第三个参数为多久执行一次 这里写1000表示每1秒执行一次mTimerTask的Run方法  
  108.         mTimer.schedule(mTimerTask, 10001000);  
  109.     }  
  110.    
  111.     }  
  112.    
  113.     public void CloseTimer() {  
  114.    
  115.     //在这里关闭mTimer 与 mTimerTask  
  116.     if (mTimer != null) {  
  117.         mTimer.cancel();  
  118.         mTimer = null;  
  119.     }  
  120.     if (mTimerTask != null) {  
  121.         mTimerTask = null;  
  122.     }  
  123.    
  124.     /**ID重置**/  
  125.     mTimerID = 0;  
  126.    
  127.     //这里发送一条只带what空的消息  
  128.     handler.sendEmptyMessage(CLOSE_PROGRESS);  
  129.     }  
  130. }  

  3.AsyncTask执行多线程

Android游戏开发教程之十六:多线程的操作方式

  执行AsyncTask

  onPreExecute()///首先执行这个方法,它在UI线程中 可以执行一些异步操作 比如初始化一些东西

  doInBackground(Object… arg0) //异步后台执行 ,执行完毕可以返回出去一个结果object对象

  onPostExecute(Object result) //可以拿到执行中的进度 当然进度须要在doInBackground中手动调用publishProgress()方法返回通过例子可以清楚的看到计算出读取100张图片的时间,执行的效率上来说AsyncTask 没有Thread效率块,但是AsyncTask 比Thread更规整,它可是时时的拿到异步线程中进度以及最后的结果集,可以让我们的代码更佳规范。这里说一下 Thread能做到的事AsyncTask 都可以做到 但是AsyncTask  能做到的事Thread 不一定能做到就算勉强做到也很麻烦 。我给大家的建议是如果处理大量的异步操作就用AsyncTask 如果少部分的则使用Thread

Java代码
  1. import java.io.InputStream;  
  2. import java.util.Timer;  
  3. import java.util.TimerTask;  
  4. import android.app.Activity;  
  5. import android.content.Context;  
  6. import android.graphics.Bitmap;  
  7. import android.graphics.BitmapFactory;  
  8. import android.os.AsyncTask;  
  9. import android.os.Bundle;  
  10. import android.view.View;  
  11. import android.view.View.OnClickListener;  
  12. import android.widget.Button;  
  13. import android.widget.TextView;  
  14.    
  15. public class AsyncTaskActivity extends Activity {  
  16.    
  17.     /**执行Timer进度**/  
  18.     public final static int LOAD_PROGRESS = 0;   
  19.    
  20.     /**关闭Timer进度**/  
  21.     public final static int CLOSE_PROGRESS = 1;   
  22.    
  23.     /** 开始StartAsync按钮 **/  
  24.     Button mButton0 = null;  
  25.    
  26.     /** 显示内容 **/  
  27.     TextView mTextView = null;  
  28.    
  29.     Context mContext = null;  
  30.    
  31.     /**Timer对象**/  
  32.     Timer mTimer = null;  
  33.    
  34.     /**TimerTask对象**/  
  35.     TimerTask mTimerTask = null;  
  36.    
  37.     /**记录TimerID**/  
  38.     int mTimerID = 0;  
  39.    
  40.     @Override  
  41.     protected void onCreate(Bundle savedInstanceState) {  
  42.     setContentView(R.layout.async);  
  43.     mContext = this;  
  44.    
  45.     /** 拿到button 与 TextView 对象 **/  
  46.     mButton0 = (Button) findViewById(R.id.button0);  
  47.     mTextView = (TextView) findViewById(R.id.textView0);  
  48.     //开始  
  49.     mButton0.setOnClickListener(new OnClickListener() {  
  50.         @Override  
  51.         public void onClick(View arg0) {  
  52.         //开始执行StartAsync  
  53.         StartAsync();  
  54.         }  
  55.     });  
  56.    
  57.     super.onCreate(savedInstanceState);  
  58.     }  
  59.    
  60.     public void StartAsync() {  
  61.     new AsyncTask<Object, Object, Object>() {  
  62.    
  63.         @Override  
  64.         protected void onPreExecute() {  
  65.         //首先执行这个方法,它在UI线程中 可以执行一些异步操作  
  66.         mTextView.setText("开始加载进度");  
  67.         super.onPreExecute();  
  68.         }  
  69.    
  70.         @Override  
  71.         protected Object doInBackground(Object… arg0) {  
  72.         //异步后台执行 ,执行完毕可以返回出去一个结果object对象  
  73.    
  74.         //得到开始加载的时间  
  75.         Long startTime = System.currentTimeMillis();  
  76.         for (int i = 0; i < 100; i++) {  
  77.             // 这里循环加载图片100遍  
  78.             ReadBitMap(mContext, R.drawable.bg);  
  79.             //执行这个方法会异步调用onProgressUpdate方法,可以用来更新UI  
  80.             publishProgress(i);  
  81.         }  
  82.         //得到结束加载的时间  
  83.         Long endTime = System.currentTimeMillis();  
  84.    
  85.         //将读取时间返回  
  86.         return endTime – startTime;  
  87.         }  
  88.    
  89.         @Override  
  90.         protected void onPostExecute(Object result) {  
  91.         //doInBackground之行结束以后在这里可以接收到返回的结果对象  
  92.    
  93.         mTextView.setText("读取100张图片一共耗时" + result+ "毫秒");  
  94.    
  95.         super.onPostExecute(result);  
  96.         }  
  97.    
  98.         @Override  
  99.         protected void onProgressUpdate(Object… values) {  
  100.             //时时拿到当前的进度更新UI  
  101.    
  102.         mTextView.setText("当前加载进度" + values[0]);  
  103.             super.onProgressUpdate(values);  
  104.         }  
  105.     }.execute();//可以理解为执行 这个AsyncTask  
  106.    
  107.     }  
  108.     /** 
  109.      * 读取本地资源的图片 
  110.      * 
  111.      * @param context 
  112.      * @param resId 
  113.      * @return 
  114.      */  
  115.     public Bitmap ReadBitMap(Context context, int resId) {  
  116.     BitmapFactory.Options opt = new BitmapFactory.Options();  
  117.     opt.inPreferredConfig = Bitmap.Config.RGB_565;  
  118.     opt.inPurgeable = true;  
  119.     opt.inInputShareable = true;  
  120.     // 获取资源图片  
  121.     InputStream is = context.getResources().openRawResource(resId);  
  122.     return BitmapFactory.decodeStream(is, null, opt);  
  123.     }  
  124. }  

  4.多线程Looper的使用

Android游戏开发教程之十六:多线程的操作方式

  Looper用来管理线程的消息队列与循环队列,在handler中默认为mainlooper来进行消息循环,如果在handler中开启一个新的线程那么在这个新的线程中就没有Looper循环,如果想让这个新的线程具有消息队列与消息循环我们须要调用 Looper.prepare();拿到它的loop ,这样就好比在Thread中创建了消息队列与循环  需要调用   Looper.loop(); 它的意思就是执行这个消息循环,下面我给出一个例子希望大家好好阅读。

Java代码
  1. import java.io.InputStream;  
  2.    
  3. import android.app.Activity;  
  4. import android.content.Context;  
  5. import android.graphics.Bitmap;  
  6. import android.graphics.BitmapFactory;  
  7. import android.os.Bundle;  
  8. import android.os.Handler;  
  9. import android.os.Looper;  
  10. import android.os.Message;  
  11. import android.view.View;  
  12. import android.view.View.OnClickListener;  
  13. import android.widget.Button;  
  14. import android.widget.Toast;  
  15.    
  16. public class LooperActivity extends Activity {  
  17.     /** 发送消息按钮 **/  
  18.     Button mButton = null;  
  19.     /** 加载图片前的时间 **/  
  20.     Long mLoadStatr = 0L;  
  21.     /** 加载图片后的时间 **/  
  22.     Long mLoadEnd = 0L;  
  23.    
  24.     Context mContext = null;  
  25.    
  26.     private Handler handler = new Handler() {  
  27.     public void handleMessage(Message msg) {  
  28.         new Thread() {  
  29.         @Override  
  30.         public void run() {  
  31.    
  32.             //如果handler不指定looper的话  
  33.             //默认为mainlooper来进行消息循环,  
  34.             //而当前是在一个新的线程中它没有默认的looper  
  35.             //所以我们须要手动调用prepare()拿到他的loop  
  36.             //可以理解为在Thread创建Looper的消息队列  
  37.             Looper.prepare();  
  38.    
  39.             Toast.makeText(LooperActivity.this"收到消息",Toast.LENGTH_LONG).show();  
  40.    
  41.             //在这里执行这个消息循环如果没有这句  
  42.             //就好比只创建了Looper的消息队列而  
  43.             //没有执行这个队列那么上面Toast的内容是不会显示出来的  
  44.             Looper.loop();  
  45.    
  46.         //如果没有   Looper.prepare();  与 Looper.loop();  
  47.         //会抛出异常Can’t create handler inside thread that has not called Looper.prepare()  
  48.         //原因是我们新起的线程中是没有默认的looper所以须要手动调用prepare()拿到他的loop  
  49.    
  50.         }  
  51.         }.start();  
  52.     }  
  53.     };  
  54.    
  55.     @Override  
  56.     protected void onCreate(Bundle savedInstanceState) {  
  57.     setContentView(R.layout.loop);  
  58.     mContext = this;  
  59.    
  60.     /** 拿到button 与 TextView 对象 **/  
  61.     mButton = (Button) findViewById(R.id.button0);  
  62.     mButton.setOnClickListener(new OnClickListener() {  
  63.         @Override  
  64.         public void onClick(View arg0) {  
  65.         new Thread() {  
  66.             @Override  
  67.             public void run() {  
  68.    
  69.                 //发送一条空的消息  
  70.                     //空消息中必需带一个what字段  
  71.                 //用于在handler中接收  
  72.                 //这里暂时我先写成0  
  73.                 handler.sendEmptyMessage(0);  
  74.    
  75.             }  
  76.         }.start();  
  77.         }  
  78.     });  
  79.    
  80.     super.onCreate(savedInstanceState);  
  81.     }  
  82.     /** 
  83.      * 读取本地资源的图片 
  84.      * 
  85.      * @param context 
  86.      * @param resId 
  87.      * @return 
  88.      */  
  89.     public Bitmap ReadBitMap(Context context, int resId) {  
  90.     BitmapFactory.Options opt = new BitmapFactory.Options();  
  91.     opt.inPreferredConfig = Bitmap.Config.RGB_565;  
  92.     opt.inPurgeable = true;  
  93.     opt.inInputShareable = true;  
  94.     // 获取资源图片  
  95.     InputStream is = context.getResources().openRawResource(resId);  
  96.     return BitmapFactory.decodeStream(is, null, opt);  
  97.     }  
  98. }  

  源码下载地址:http://vdisk.weibo.com/s/aakLw

-上面就是Android游戏开发教程之十六:多线程的操作方式分享全部内容. 如果需要了解更多android开发及android游戏开发内容关注<猴子技术宅>

本文来自网络收集,不代表猴子技术宅立场,如涉及侵权请点击右边联系管理员删除。

如若转载,请注明出处:https://www.ssfiction.com/makeofgames/andiordkaifa/504949.html

发表评论

电子邮件地址不会被公开。 必填项已用*标注