Android游戏开发之多线程的操作方式（二十六）

最新推荐文章于 2024-09-18 15:29:47 发布
最新推荐文章于 2024-09-18 15:29:47 发布
阅读量770 收藏
点赞数
分类专栏： Android 文章标签： 多线程 android 游戏 button timer null
Android游戏开发之多线程的操作方式





雨松MOMO原创文章如转载，请注明：转载至我的独立域名博客雨松MOMO程序研究院，原文地址:http://www.xuanyusong.com/archives/344






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




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







1.Thread与Handler执行多线程









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



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

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class SingleActivity extends Activity {

    /**读取进度**/
    public final static int LOAD_PROGRESS = 0; 
    
    /**标志读取进度结束**/
    public final static int LOAD_COMPLETE = 1; 
    
    
    /** 开始加载100张图片按钮 **/
    Button mButton = null;
    /** 显示内容 **/
    TextView mTextView = null;
    /** 加载图片前的时间 **/
    Long mLoadStatr = 0L;
    /** 加载图片后的时间 **/
    Long mLoadEnd = 0L;

    Context mContext = null;

    //接收传递过来的信息
    Handler handler = new Handler() {
	@Override
	public void handleMessage(Message msg) {
	    switch (msg.what) {
	    case LOAD_PROGRESS:
		mTextView.setText("当前读取到第" + msg.arg1 + "张图片");
		break;
	    case LOAD_COMPLETE:
		mTextView.setText("读取结束一共耗时" + msg.arg1 + "毫秒");
		break;
	    }
	    super.handleMessage(msg);
	}
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
	setContentView(R.layout.single);
	mContext = this;

	/** 拿到button 与 TextView 对象 **/
	mButton = (Button) findViewById(R.id.button0);
	mTextView = (TextView) findViewById(R.id.textView0);
	mTextView.setText("点击按钮开始更新时间");
	mButton.setOnClickListener(new OnClickListener() {
	    @Override
	    public void onClick(View arg0) {
		//开始读取图片
		LoadImage();
	    }
	});

	
	super.onCreate(savedInstanceState);
    }

    public void LoadImage() {
	new Thread() {
	    @Override
	    public void run() {
		//得到加载图片开始的时间
		mLoadStatr = System.currentTimeMillis();
		
		for (int i = 0; i < 100; i++) {
		    // 这里循环加载图片100遍
		    ReadBitMap(mContext, R.drawable.bg);

		    // 每读取完一张图片将进度甩给handler
		    Message msg = new Message();
		    msg.what = LOAD_PROGRESS;
		    msg.arg1 = i + 1;
		    handler.sendMessage(msg);
		}
		
		//得到加载图片结束的时间
		mLoadEnd = System.currentTimeMillis();
		
		//100张图片加载完成
		Message msg = new Message();
		msg.what = LOAD_COMPLETE;
		msg.arg1 = (int) (mLoadEnd - mLoadStatr);
		handler.sendMessage(msg);
	    }
	}.start();

    }

    /**
     * 读取本地资源的图片
     * 
     * @param context
     * @param resId
     * @return
     */
    public Bitmap ReadBitMap(Context context, int resId) {
	BitmapFactory.Options opt = new BitmapFactory.Options();
	opt.inPreferredConfig = Bitmap.Config.RGB_565;
	opt.inPurgeable = true;
	opt.inInputShareable = true;
	// 获取资源图片
	InputStream is = context.getResources().openRawResource(resId);
	return BitmapFactory.decodeStream(is, null, opt);
    }
}




2.TimerTask与Handler延迟多线程







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


[java] view plain copy print ?
  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.     /**接收传递过来的信息**/  
  43.     Handler handler = new Handler() {  
  44.     @Override  
  45.     public void handleMessage(Message msg) {  
  46.         switch (msg.what) {  
  47.         case LOAD_PROGRESS:  
  48.         mTextView.setText("当前TimerID为" + msg.arg1 );  
  49.         break;  
  50.         case CLOSE_PROGRESS:  
  51.         mTextView.setText("当前Timer已经关闭请重新开启" );  
  52.         break;  
  53.           
  54.         }  
  55.         super.handleMessage(msg);  
  56.     }  
  57.     };  
  58.   
  59.     @Override  
  60.     protected void onCreate(Bundle savedInstanceState) {  
  61.     setContentView(R.layout.timer);  
  62.     mContext = this;  
  63.   
  64.     /** 拿到button 与 TextView 对象 **/  
  65.     mButton0 = (Button) findViewById(R.id.button0);  
  66.     mButton1 = (Button) findViewById(R.id.button1);  
  67.     mTextView = (TextView) findViewById(R.id.textView0);  
  68.     mTextView.setText("点击按钮开始更新时间");  
  69.       
  70.     //开始  
  71.     mButton0.setOnClickListener(new OnClickListener() {  
  72.         @Override  
  73.         public void onClick(View arg0) {  
  74.         //开始执行timer  
  75.         StartTimer();  
  76.         }  
  77.     });  
  78.   
  79.     //关闭  
  80.     mButton1.setOnClickListener(new OnClickListener() {  
  81.         @Override  
  82.         public void onClick(View arg0) {  
  83.         //停止执行timer  
  84.         CloseTimer();  
  85.         }  
  86.     });  
  87.       
  88.     super.onCreate(savedInstanceState);  
  89.     }  
  90.   
  91.     public void StartTimer() {  
  92.   
  93.     if (mTimer == null) {  
  94.         mTimerTask = new TimerTask() {  
  95.         public void run() {  
  96.             //mTimerTask与mTimer执行的前提下每过1秒进一次这里  
  97.             mTimerID ++;  
  98.             Message msg = new Message();  
  99.             msg.what = LOAD_PROGRESS;  
  100.             msg.arg1 = (int) (mTimerID);  
  101.             handler.sendMessage(msg);  
  102.         }  
  103.         };  
  104.         mTimer = new Timer();  
  105.         
  106.         //第一个参数为执行的mTimerTask  
  107.         //第二个参数为延迟的时间 这里写1000的意思是mTimerTask将延迟1秒执行  
  108.         //第三个参数为多久执行一次 这里写1000表示每1秒执行一次mTimerTask的Run方法  
  109.         mTimer.schedule(mTimerTask, 1000, 1000);  
  110.     }  
  111.   
  112.     }  
  113.   
  114.     public void CloseTimer() {  
  115.   
  116.     //在这里关闭mTimer 与 mTimerTask  
  117.     if (mTimer != null) {  
  118.         mTimer.cancel();  
  119.         mTimer = null;  
  120.     }  
  121.     if (mTimerTask != null) {  
  122.         mTimerTask = null;  
  123.     }  
  124.       
  125.     /**ID重置**/  
  126.     mTimerID = 0;  
  127.       
  128.     //这里发送一条只带what空的消息  
  129.     handler.sendEmptyMessage(CLOSE_PROGRESS);  
  130.     }  
  131. }  
import java.util.Timer;
import java.util.TimerTask;
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class TimerTaskActivity extends Activity {

    /**执行Timer进度**/
    public final static int LOAD_PROGRESS = 0; 
    
    /**关闭Timer进度**/
    public final static int CLOSE_PROGRESS = 1; 
    
    /** 开始TimerTask按钮 **/
    Button mButton0 = null;
    
    /** 关闭TimerTask按钮 **/
    Button mButton1 = null;
    
    /** 显示内容 **/
    TextView mTextView = null;

    Context mContext = null;

    /**Timer对象**/
    Timer mTimer = null;
    
    /**TimerTask对象**/
    TimerTask mTimerTask = null;
   
    /**记录TimerID**/
    int mTimerID = 0;
    
    
    /**接收传递过来的信息**/
    Handler handler = new Handler() {
	@Override
	public void handleMessage(Message msg) {
	    switch (msg.what) {
	    case LOAD_PROGRESS:
		mTextView.setText("当前TimerID为" + msg.arg1 );
		break;
	    case CLOSE_PROGRESS:
		mTextView.setText("当前Timer已经关闭请重新开启" );
		break;
	    
	    }
	    super.handleMessage(msg);
	}
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
	setContentView(R.layout.timer);
	mContext = this;

	/** 拿到button 与 TextView 对象 **/
	mButton0 = (Button) findViewById(R.id.button0);
	mButton1 = (Button) findViewById(R.id.button1);
	mTextView = (TextView) findViewById(R.id.textView0);
	mTextView.setText("点击按钮开始更新时间");
	
	//开始
	mButton0.setOnClickListener(new OnClickListener() {
	    @Override
	    public void onClick(View arg0) {
		//开始执行timer
		StartTimer();
	    }
	});

	//关闭
	mButton1.setOnClickListener(new OnClickListener() {
	    @Override
	    public void onClick(View arg0) {
		//停止执行timer
		CloseTimer();
	    }
	});
	
	super.onCreate(savedInstanceState);
    }

    public void StartTimer() {

	if (mTimer == null) {
	    mTimerTask = new TimerTask() {
		public void run() {
		    //mTimerTask与mTimer执行的前提下每过1秒进一次这里
		    mTimerID ++;
		    Message msg = new Message();
		    msg.what = LOAD_PROGRESS;
		    msg.arg1 = (int) (mTimerID);
		    handler.sendMessage(msg);
		}
	    };
	    mTimer = new Timer();
	  
	    //第一个参数为执行的mTimerTask
	    //第二个参数为延迟的时间 这里写1000的意思是mTimerTask将延迟1秒执行
	    //第三个参数为多久执行一次 这里写1000表示每1秒执行一次mTimerTask的Run方法
	    mTimer.schedule(mTimerTask, 1000, 1000);
	}

    }

    public void CloseTimer() {

	//在这里关闭mTimer 与 mTimerTask
	if (mTimer != null) {
	    mTimer.cancel();
	    mTimer = null;
	}
	if (mTimerTask != null) {
	    mTimerTask = null;
	}
	
	/**ID重置**/
	mTimerID = 0;
	
	//这里发送一条只带what空的消息
	handler.sendEmptyMessage(CLOSE_PROGRESS);
    }
}




3.AsyncTask执行多线程








执行AsyncTask
onPreExecute()///首先执行这个方法，它在UI线程中 可以执行一些异步操作 比如初始化一些东西
doInBackground(Object... arg0) //异步后台执行 ，执行完毕可以返回出去一个结果object对象
onPostExecute(Object result) //可以拿到执行中的进度 当然进度须要在doInBackground中手动调用publishProgress()方法返回

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


[java] view plain copy print ?
  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.     /** 显示内容 **/  
  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.     @Override  
  42.     protected void onCreate(Bundle savedInstanceState) {  
  43.     setContentView(R.layout.async);  
  44.     mContext = this;  
  45.   
  46.     /** 拿到button 与 TextView 对象 **/  
  47.     mButton0 = (Button) findViewById(R.id.button0);  
  48.     mTextView = (TextView) findViewById(R.id.textView0);  
  49.     //开始  
  50.     mButton0.setOnClickListener(new OnClickListener() {  
  51.         @Override  
  52.         public void onClick(View arg0) {  
  53.         //开始执行StartAsync  
  54.         StartAsync();  
  55.         }  
  56.     });  
  57.   
  58.       
  59.     super.onCreate(savedInstanceState);  
  60.     }  
  61.   
  62.     public void StartAsync() {  
  63.     new AsyncTask<Object, Object, Object>() {  
  64.          
  65.         @Override  
  66.         protected void onPreExecute() {  
  67.         //首先执行这个方法，它在UI线程中 可以执行一些异步操作  
  68.         mTextView.setText("开始加载进度");  
  69.         super.onPreExecute();  
  70.         }  
  71.   
  72.         @Override  
  73.         protected Object doInBackground(Object... arg0) {  
  74.         //异步后台执行 ，执行完毕可以返回出去一个结果object对象  
  75.           
  76.         //得到开始加载的时间  
  77.         Long startTime = System.currentTimeMillis();  
  78.         for (int i = 0; i < 100; i++) {  
  79.             // 这里循环加载图片100遍  
  80.             ReadBitMap(mContext, R.drawable.bg);  
  81.             //执行这个方法会异步调用onProgressUpdate方法，可以用来更新UI  
  82.             publishProgress(i);  
  83.         }  
  84.         //得到结束加载的时间  
  85.         Long endTime = System.currentTimeMillis();  
  86.           
  87.         //将读取时间返回  
  88.         return endTime - startTime;  
  89.         }  
  90.   
  91.         @Override  
  92.         protected void onPostExecute(Object result) {  
  93.         //doInBackground之行结束以后在这里可以接收到返回的结果对象  
  94.           
  95.         mTextView.setText("读取100张图片一共耗时" + result+ "毫秒");  
  96.           
  97.         super.onPostExecute(result);  
  98.         }  
  99.           
  100.           
  101.         @Override  
  102.         protected void onProgressUpdate(Object... values) {  
  103.             //时时拿到当前的进度更新UI  
  104.           
  105.         mTextView.setText("当前加载进度" + values[0]);  
  106.             super.onProgressUpdate(values);  
  107.         }  
  108.     }.execute();//可以理解为执行 这个AsyncTask  
  109.   
  110.     }  
  111.     /** 
  112.      * 读取本地资源的图片 
  113.      *  
  114.      * @param context 
  115.      * @param resId 
  116.      * @return 
  117.      */  
  118.     public Bitmap ReadBitMap(Context context, int resId) {  
  119.     BitmapFactory.Options opt = new BitmapFactory.Options();  
  120.     opt.inPreferredConfig = Bitmap.Config.RGB_565;  
  121.     opt.inPurgeable = true;  
  122.     opt.inInputShareable = true;  
  123.     // 获取资源图片  
  124.     InputStream is = context.getResources().openRawResource(resId);  
  125.     return BitmapFactory.decodeStream(is, null, opt);  
  126.     }  
  127. }  
import java.io.InputStream;
import java.util.Timer;
import java.util.TimerTask;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class AsyncTaskActivity extends Activity {

    /**执行Timer进度**/
    public final static int LOAD_PROGRESS = 0; 
    
    /**关闭Timer进度**/
    public final static int CLOSE_PROGRESS = 1; 
    
    /** 开始StartAsync按钮 **/
    Button mButton0 = null;
    
    
    /** 显示内容 **/
    TextView mTextView = null;

    Context mContext = null;

    /**Timer对象**/
    Timer mTimer = null;
    
    /**TimerTask对象**/
    TimerTask mTimerTask = null;
   
    /**记录TimerID**/
    int mTimerID = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
	setContentView(R.layout.async);
	mContext = this;

	/** 拿到button 与 TextView 对象 **/
	mButton0 = (Button) findViewById(R.id.button0);
	mTextView = (TextView) findViewById(R.id.textView0);
	//开始
	mButton0.setOnClickListener(new OnClickListener() {
	    @Override
	    public void onClick(View arg0) {
		//开始执行StartAsync
		StartAsync();
	    }
	});

	
	super.onCreate(savedInstanceState);
    }

    public void StartAsync() {
	new AsyncTask<Object, Object, Object>() {
	   
	    @Override
	    protected void onPreExecute() {
		//首先执行这个方法，它在UI线程中 可以执行一些异步操作
		mTextView.setText("开始加载进度");
		super.onPreExecute();
	    }

	    @Override
	    protected Object doInBackground(Object... arg0) {
		//异步后台执行 ，执行完毕可以返回出去一个结果object对象
		
		//得到开始加载的时间
		Long startTime = System.currentTimeMillis();
		for (int i = 0; i < 100; i++) {
		    // 这里循环加载图片100遍
		    ReadBitMap(mContext, R.drawable.bg);
		    //执行这个方法会异步调用onProgressUpdate方法，可以用来更新UI
		    publishProgress(i);
		}
		//得到结束加载的时间
		Long endTime = System.currentTimeMillis();
		
		//将读取时间返回
		return endTime - startTime;
	    }

	    @Override
	    protected void onPostExecute(Object result) {
		//doInBackground之行结束以后在这里可以接收到返回的结果对象
		
		mTextView.setText("读取100张图片一共耗时" + result+ "毫秒");
		
		super.onPostExecute(result);
	    }
	    
	    
	    @Override
	    protected void onProgressUpdate(Object... values) {
	        //时时拿到当前的进度更新UI
		
		mTextView.setText("当前加载进度" + values[0]);
	        super.onProgressUpdate(values);
	    }
	}.execute();//可以理解为执行 这个AsyncTask

    }
    /**
     * 读取本地资源的图片
     * 
     * @param context
     * @param resId
     * @return
     */
    public Bitmap ReadBitMap(Context context, int resId) {
	BitmapFactory.Options opt = new BitmapFactory.Options();
	opt.inPreferredConfig = Bitmap.Config.RGB_565;
	opt.inPurgeable = true;
	opt.inInputShareable = true;
	// 获取资源图片
	InputStream is = context.getResources().openRawResource(resId);
	return BitmapFactory.decodeStream(is, null, opt);
    }
}




4.多线程Looper的使用










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



[java] view plain copy print ?
  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.               
  40.             Toast.makeText(LooperActivity.this, "收到消息",Toast.LENGTH_LONG).show();  
  41.              
  42.               
  43.             //在这里执行这个消息循环如果没有这句  
  44.             //就好比只创建了Looper的消息队列而  
  45.             //没有执行这个队列那么上面Toast的内容是不会显示出来的  
  46.             Looper.loop();  
  47.           
  48.           
  49.           
  50.           
  51.         //如果没有   Looper.prepare();  与 Looper.loop();  
  52.         //会抛出异常Can't create handler inside thread that has not called Looper.prepare()     
  53.         //原因是我们新起的线程中是没有默认的looper所以须要手动调用prepare()拿到他的loop  
  54.           
  55.         }  
  56.         }.start();  
  57.     }  
  58.     };  
  59.       
  60.     @Override  
  61.     protected void onCreate(Bundle savedInstanceState) {  
  62.     setContentView(R.layout.loop);  
  63.     mContext = this;  
  64.   
  65.     /** 拿到button 与 TextView 对象 **/  
  66.     mButton = (Button) findViewById(R.id.button0);  
  67.     mButton.setOnClickListener(new OnClickListener() {  
  68.         @Override  
  69.         public void onClick(View arg0) {  
  70.         new Thread() {  
  71.             @Override  
  72.             public void run() {  
  73.           
  74.                 //发送一条空的消息  
  75.                     //空消息中必需带一个what字段  
  76.                 //用于在handler中接收  
  77.                 //这里暂时我先写成0  
  78.                 handler.sendEmptyMessage(0);  
  79.           
  80.             }  
  81.         }.start();  
  82.         }  
  83.     });  
  84.   
  85.       
  86.     super.onCreate(savedInstanceState);  
  87.     }  
  88.     /** 
  89.      * 读取本地资源的图片 
  90.      *  
  91.      * @param context 
  92.      * @param resId 
  93.      * @return 
  94.      */  
  95.     public Bitmap ReadBitMap(Context context, int resId) {  
  96.     BitmapFactory.Options opt = new BitmapFactory.Options();  
  97.     opt.inPreferredConfig = Bitmap.Config.RGB_565;  
  98.     opt.inPurgeable = true;  
  99.     opt.inInputShareable = true;  
  100.     // 获取资源图片  
  101.     InputStream is = context.getResources().openRawResource(resId);  
  102.     return BitmapFactory.decodeStream(is, null, opt);  
  103.     }  
  104. }  
import java.io.InputStream;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class LooperActivity extends Activity {
    /** 发送消息按钮 **/
    Button mButton = null;
    /** 加载图片前的时间 **/
    Long mLoadStatr = 0L;
    /** 加载图片后的时间 **/
    Long mLoadEnd = 0L;

    Context mContext = null;

    private Handler handler = new Handler() {
	public void handleMessage(Message msg) {
	    new Thread() {
		@Override
		public void run() {
		   
		    //如果handler不指定looper的话
		    //默认为mainlooper来进行消息循环，
		    //而当前是在一个新的线程中它没有默认的looper
		    //所以我们须要手动调用prepare()拿到他的loop 
		    //可以理解为在Thread创建Looper的消息队列
		    Looper.prepare();
		    
		    
		    Toast.makeText(LooperActivity.this, "收到消息",Toast.LENGTH_LONG).show();
		   
		    
		    //在这里执行这个消息循环如果没有这句
		    //就好比只创建了Looper的消息队列而
		    //没有执行这个队列那么上面Toast的内容是不会显示出来的
		    Looper.loop();
		
		
		
		
		//如果没有   Looper.prepare();  与 Looper.loop();
		//会抛出异常Can't create handler inside thread that has not called Looper.prepare()   
		//原因是我们新起的线程中是没有默认的looper所以须要手动调用prepare()拿到他的loop
		
		}
	    }.start();
	}
	};
	
    @Override
    protected void onCreate(Bundle savedInstanceState) {
	setContentView(R.layout.loop);
	mContext = this;

	/** 拿到button 与 TextView 对象 **/
	mButton = (Button) findViewById(R.id.button0);
	mButton.setOnClickListener(new OnClickListener() {
	    @Override
	    public void onClick(View arg0) {
		new Thread() {
		    @Override
		    public void run() {
		
			    //发送一条空的消息
		            //空消息中必需带一个what字段
			    //用于在handler中接收
			    //这里暂时我先写成0
			    handler.sendEmptyMessage(0);
		
		    }
		}.start();
	    }
	});

	
	super.onCreate(savedInstanceState);
    }
    /**
     * 读取本地资源的图片
     * 
     * @param context
     * @param resId
     * @return
     */
    public Bitmap ReadBitMap(Context context, int resId) {
	BitmapFactory.Options opt = new BitmapFactory.Options();
	opt.inPreferredConfig = Bitmap.Config.RGB_565;
	opt.inPurgeable = true;
	opt.inInputShareable = true;
	// 获取资源图片
	InputStream is = context.getResources().openRawResource(resId);
	return BitmapFactory.decodeStream(is, null, opt);
    }
}


老规矩每篇文章都会附带源代码，最后如果你还是觉得我写的不够详细 看的不够爽 不要紧我把源代码的下载地址贴出来 欢迎大家一起讨论学习雨松MOMO希望可以和大家一起进步。


下载地址：http://download.csdn.net/source/3537962
menuconfig
关注
专栏目录
棋牌游戏中机器人接口
Incremental Learning
01-21 3566
所谓棋牌游戏中的机器人是相对游戏中的真实玩家而言的，机器人即电脑程序，通俗点讲就好比玩单机棋牌游戏你一个人在跟“电脑”玩（如明星三缺一），这里的“电脑”在网络棋牌游戏中就称作机器人。   网络棋牌游戏机器人的作用有两个方面： 1、程序的稳定性以及负载性测试，游戏程序刚开发或者更新后为了找出BUG需要大量的玩家来试玩，真实玩家较难找到想要的数量，此时用机器人即可以有效的节约成本
棋牌游戏服务器架构设计
weixin_34143774的博客
09-21 1288
https://www.cnblogs.com/wgslucky/p/6426544.html
Android Native APP开发笔记：多线程编程
Naisu的各种笔记
10-31 1141
Android中UI线程对于开发者和用户来说都是最主要接触到的线程。一般来说为了UI流畅、不卡顿，耗时操作是不推荐放在UI线程中的。但是耗时操作的需求又是存在的，这时候就需要用到多线程编程了，新建一条子线程去处理耗时操作。这篇文章将对相关内容进行简单介绍。
android studio游戏摇杆开发教程，仿王者荣耀摇杆
热门推荐
李子果 - 博客
06-16 150万+
最近在做一个山寨版的王者荣耀，刚开始做的时候毫无头绪 摇杆的多点触控做的特别烂 经过几天的思考已完美解决所有问题，下面就和大家分享下这个摇杆的开发思路（此教程不包含游戏源码） 若有不正之处，请多多谅解并欢迎指正。 首先这个摇杆要用到较多的数学知识，小编的数学特别烂也就高中水平吧 我们这个摇杆一共就五个按钮，一个移动摇杆、三个技能摇杆和一个普通攻击按钮 最终效果 ...
Android游戏开发之多线程的操作方式
GaoMatrix的专栏
08-27 2618
转载自雨松MOMO的博客原文地址:http://blog.csdn.net/xys289187120/article/details/6706952 游戏开发与软件开发多线程的重要性 如果程序主线程被阻塞超过5秒，系统会提示“应用程序无响应” 这就是ANR 。 ANR
Android中的多线程开发（UI更新、Handler使用）
weixin_47323733的博客
01-16 1919
Android 多线程开发 1. 线程概念 1.1 进程概念 一般来说，可以在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行的程序，而每一个进程都有自己独立的一块内存空间、一组系统资源。在进程的概念中每一个进程内部数据状态都是完全独立的。 1.2 线程概念 多线程指的是在单个程序中可以同时运行多个不同的线程，执行不同的任务。线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制。但与进程不同的是，同类型的多个线程是共享一块内存空间和一组系统资源。所以，多个线程之间切换时
Android中的多线程及AsyncTask的引入，android小游戏开发实例
m0_66144910的博客
01-12 1919
----------------------------- 1.主要代码 public class DelayOperator { //延时操作,用来模拟下载 public void delay() { try { Thread.sleep(1000); }catch (InterruptedException e){ e.printStackTrace(); } } } public class MyAsyncTask extends AsyncTask<Integer,Integer,String
Android开发之多线程的操作方式Thread,TimerTask,AsyncTask
u011470899的专栏
08-22 2606
Android游戏开发之多线程的操作方式 雨松MOMO原创文章如转载，请注明：转载至我的独立域名博客雨松MOMO程序研究院，原文地址:http://www.xuanyusong.com/archives/344 游戏开发与软件开发多线程的重要性       如果程序主线程被阻塞超过5秒，系统会提示“应用程序无响应” 这就
Android 3D游戏开发技术详解与典型案例
hevenangel的博客
11-15 2194
下载地址 《Android3D游戏开发技术详解与典型案例》主要以Android平台下3D游戏的开发为主题，并结合真实的案例向读者详细介绍了OpenGL ES的基础 知识及3D游戏程序开发的整个流程。 全书分为两篇共22章，第一篇以简单易懂的实例为依托，详细介绍了 OpenGLES各方面的基础知识，第二篇则对7个真实案例的开发步骤进行了 详细的介绍，逐步向读者讲解Android3D游戏的真实开发过...
Android游戏开发之多线程的操作方式源码
08-21
本资源"Android游戏开发之多线程的操作方式源码"正是针对这一主题提供了深入的学习材料，适合对Android游戏开发感兴趣的开发者进行研究和实践。 首先，我们要理解Android系统的线程模型。在Android中，所有的应用...
21天学习android开发教程之SurfaceView与多线程的混搭
09-02
在Android开发中，SurfaceView是一个特殊的视图类，常用于...理解并掌握这一技术对于Android游戏开发或高性能图形应用至关重要。实践中，开发者应根据具体需求灵活运用，合理安排线程任务，确保应用的稳定性和性能。
Android开发之多线程中实现利用自定义控件绘制小球并完成小球自动下落功能实例
09-03
在Android开发中，多线程和自定义控件的运用能极大地提升应用的用户体验和性能。本实例将探讨如何在Android环境下，通过多线程处理和自定义控件技术实现小球自动下落的功能。 首先，我们要理解Android的多线程编程...
Android游戏开发之黑白棋
01-20
在Android游戏开发中，制作一款黑白棋应用涉及多个关键技术点，包括游戏逻辑、用户界面以及人工智能的实现。以下是对这些知识点的详细说明： 1. **游戏逻辑**：黑白棋（Reversi）的核心规则是玩家轮流在棋盘的空位...
在Android中fragment的生命周期
LLZjiayou的博客
09-18 545
Fragment的生命周期非常类似于Activity，但是它有自己特有的生命周期方法（如），因为Fragment的视图可能会被销毁和重建。
android 14.0 USB连接模式默认设为MTP
安卓兼职framework和app工程师的博客
09-13 453
在14.0android系统产品开发中，在通过otg连接设备的时候，会弹出usb连接模式这时候会让客户选择当前连接电脑是 哪种模式，在项目开发中，需要以mtp模式，就是可以在电脑查看设备的内部存储的样式来设置otg连接电脑的模式， 接下来分析下相关模式，来具体实现相关功能
Shell篇之编写php启动脚本
最新发布
小橙子的笔记屋
09-18 164
shell编写php启动脚本
百度Android IM SDK组件能力建设及应用
lihui49的博客
09-18 1046
即时通讯系统（Instant Messaging，简称IM系统）是一种允许用户通过互联网实时交换信息的通信技术。核心功能包括消息的发送与接收、用户状态的管理、消息、会话的存储与检索等。为了更好地满足用户更多场景诉求，IM系统还提供了如群组聊天、文件传输、语音和视频通话等功能。
Android14 蓝牙 BluetoothService 启动和相关代码介绍
wenzhi的博客
09-14 1857
蓝牙开关和使能开发主要用到：BluetoothService、BluetoothManagerService、BluetoothManager、BluetoothAdapter 这几个系统相关类。某个蓝牙的配对、连接、断开 使用的是 BluetoothDevice 对象。蓝牙开关状态不记忆或者打开异常就可以看看BluetoothManagerService的日志，里面有打开关闭相关过程日志和时间点，这个对问题分析有一定的帮助。本文主要介绍一下 framework 相关的几个类，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值