`
longgangbai
  • 浏览: 7340160 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

【转】有关Android线程的学习

 
阅读更多

1. Android进程

    在了解Android线程之前得先了解一下Android的进程。当一个程序第一次启动的时候,Android会启动一个LINUX进程和一个主线程。默认的情况下,所有该程序的组件都将在该进程和线程中运行。同时,Android会为每个应用程序分配一个单独的LINUX用户。Android会尽量保留一个正在运行进程,只在内存资源出现不足时,Android会尝试停止一些进程从而释放足够的资源给其他新的进程使用, 也能保证用户正在访问的当前进程有足够的资源去及时地响应用户的事件。Android会根据进程中运行的组件类别以及组件的状态来判断该进程的重要性,Android会首先停止那些不重要的进程。按照重要性从高到低一共有五个级别:

  • 前台进程
    前台进程是用户当前正在使用的进程。只有一些前台进程可以在任何时候都存在。他们是最后一个被结束的,当内存低到根本连他们都不能运行的时候。一般来说, 在这种情况下,设备会进行内存调度,中止一些前台进程来保持对用户交互的响应。
  • 可见进程
    可见进程不包含前台的组件但是会在屏幕上显示一个可见的进程是的重要程度很高,除非前台进程需要获取它的资源,不然不会被中止。
  • 服务进程
    运行着一个通过startService() 方法启动的service,这个service不属于上面提到的2种更高重要性的。service所在的进程虽然对用户不是直接可见的,但是他们执行了用户非常关注的任务(比如播放mp3,从网络下载数据)。只要前台进程和可见进程有足够的内存,系统不会回收他们。
  • 后台进程
    运行着一个对用户不可见的activity(调用过 onStop() 方法).这些进程对用户体验没有直接的影响,可以在服务进程、可见进程、前台进 程需要内存的时候回收。通常,系统中会有很多不可见进程在运行,他们被保存在LRU (least recently used) 列表中,以便内存不足的时候被第一时间回收。如果一个activity正 确的执行了它的生命周期,关闭这个进程对于用户体验没有太大的影响。
  • 空进程
    未运行任何程序组件。运行这些进程的唯一原因是作为一个缓存,缩短下次程序需要重新使用的启动时间。系统经常中止这些进程,这样可以调节程序缓存和系统缓存的平衡。

    Android 对进程的重要性评级的时候,选取它最高的级别。另外,当被另外的一个进程依赖的时候,某个进程的级别可能会增高。一个为其他进程服务的进程永远不会比被服务的进程重要级低。因为服务进程比后台activity进程重要级高,因此一个要进行耗时工作的activity最好启动一个service来做这个工作,而不是开启一个子进程――特别是这个操作需要的时间比activity存在的时间还要长的时候。例如,在后台播放音乐,向网上上传摄像头拍到的图片,使用service可以使进程最少获取到“服务进程”级别的重要级,而不用考虑activity目前是什么状态。broadcast receivers做费时的工作的时候,也应该启用一个服务而不是开一个线程。

 

2. 单线程模型

    当一个程序第一次启动时,Android会同时启动一个对应的主线程(Main Thread),主线程主要负责处理与UI相关的事件,如用户的按键事件,用户接触屏幕的事件以及屏幕绘图事件,并把相关的事件分发到对应的组件进行处理。所以主线程通常又被叫做UI线程在开发Android应用时必须遵守单线程模型的原则: Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。

 

2.1 子线程更新UI

    Android的UI是单线程(Single-threaded)的。为了避免拖住GUI,一些较费时的对象应该交给独立的线程去执行。如果幕后的线程来执行UI对象,Android就会发出错误讯息 CalledFromWrongThreadException。以后遇到这样的异常抛出时就要知道怎么回事了!

 

2.2 Message Queue

     在单线程模型下,为了解决类似的问题,Android设计了一个Message Queue(消息队列), 线程间可以通过该Message Queue并结合Handler和Looper组件进行信息交换。下面将对它们进行分别介绍:

    1. Message
    Message消息,理解为线程间交流的信息,处理数据后台线程需要更新UI,则发送Message内含一些数据给UI线程。
 
    2. Handler
    Handler处理者,是Message的主要处理者,负责Message的发送,Message内容的执行处理。后台线程就是通过传进来的Handler对象引用来sendMessage(Message)。而使用Handler,需要implement 该类的 handleMessage(Message)方法,它是处理这些Message的操作内容,例如Update UI。通常需要子类化Handler来实现handleMessage方法。
 
    3. Message Queue
    Message Queue消息队列,用来存放通过Handler发布的消息,按照先进先出执行。
    每个message queue都会有一个对应的Handler。Handler会向message queue通过两种方法发送消息:sendMessage或post。这两种消息都会插在message queue队尾并按先进先出执行。但通过这两种方法发送的消息执行的方式略有不同:通过sendMessage发送的是一个message对象,会被Handler的handleMessage()函数处理;而通过post方法发送的是一个runnable对象,则会自己执行。
 
    4. Looper
    Looper是每条线程里的Message Queue的管家。Android没有Global的Message Queue,而Android会自动替主线程(UI线程)建立Message Queue,但在子线程里并没有建立Message Queue。所以调用Looper.getMainLooper()得到的主线程的Looper不为NULL,但调用Looper.myLooper()得到当前线程的Looper就有可能为NULL。

    对于子线程使用Looper,API Doc提供了正确的使用方法:

  1. class LooperThread extends Thread { 
  2.     public Handler mHandler; 
  3.  
  4.     public void run() { 
  5.         Looper.prepare(); //创建本线程的Looper并创建一个MessageQueue
  6.  
  7.         mHandler = new Handler() { 
  8.             public void handleMessage(Message msg) { 
  9.                 // process incoming messages here 
  10.             } 
  11.         }; 
  12.    
  13.         Looper.loop(); //开始运行Looper,监听Message Queue 
  14.     } 
 

    这个Message机制的大概流程:

    1. 在Looper.loop()方法运行开始后,循环地按照接收顺序取出Message Queue里面的非NULL的Message。

    2. 一开始Message Queue里面的Message都是NULL的。当Handler.sendMessage(Message)到Message Queue,该函数里面设置了那个Message对象的target属性是当前的Handler对象。随后Looper取出了那个Message,则调用该Message的target指向的Hander的dispatchMessage函数对Message进行处理。

    在dispatchMessage方法里,如何处理Message则由用户指定,三个判断,优先级从高到低:

    1) Message里面的Callback,一个实现了Runnable接口的对象,其中run函数做处理工作;

    2) Handler里面的mCallback指向的一个实现了Callback接口的对象,由其handleMessage进行处理;

    3) 处理消息Handler对象对应的类继承并实现了其中handleMessage函数,通过这个实现的handleMessage函数处理消息。

    由此可见,我们实现的handleMessage方法是优先级最低的!

    3. Handler处理完该Message (update UI) 后,Looper则设置该Message为NULL,以便回收!

 
    在网上有很多文章讲述主线程和其他子线程如何交互,传送信息,最终谁来执行处理信息之类的,个人理解是最简单的方法——判断Handler对象里面的Looper对象是属于哪条线程的,则由该线程来执行!
    1. 当Handler对象的构造函数的参数为空,则为当前所在线程的Looper;
    2. Looper.getMainLooper()得到的是主线程的Looper对象,Looper.myLooper()得到的是当前线程的Looper对象。

现在来看一个例子,模拟从网络获取数据,加载到ListView的过程:

  1. public class ListProgressDemo extends ListActivity { 
  2.  
  3.     @Override 
  4.     public void onCreate(Bundle savedInstanceState) { 
  5.         super.onCreate(savedInstanceState); 
  6.         setContentView(R.layout.listprogress); 
  7.  
  8.         ((Button) findViewById(R.id.load_Handler)).setOnClickListener(new View.OnClickListener(){ 
  9.  
  10.             @Override 
  11.             public void onClick(View view) { 
  12.                 data = null
  13.                 data = new ArrayList<String>(); 
  14.  
  15.                 adapter = null
  16.  
  17.                 showDialog(PROGRESS_DIALOG); 
  18.                 new ProgressThread(handler, data).start(); 
  19.             } 
  20.         }); 
  21.     } 
  22.  
  23.     @Override 
  24.     protected Dialog onCreateDialog(int id) { 
  25.         switch(id) { 
  26.         case PROGRESS_DIALOG: 
  27.                  return ProgressDialog.show(this"",  
  28.                    "Loading. Please wait..."true); 
  29.  
  30.         defaultreturn null
  31.         } 
  32.     } 
  33.  
  34.     private class ProgressThread extends Thread { 
  35.  
  36.         private Handler handler; 
  37.         private ArrayList<String> data; 
  38.  
  39.         public ProgressThread(Handler handler, ArrayList<String> data) { 
  40.             this.handler = handler; 
  41.             this.data = data; 
  42.         } 
  43.  
  44.         @Override 
  45.         public void run() { 
  46.             for (int i=0; i<8; i++) { 
  47.                 data.add("ListItem"); //后台数据处理
  48.                 try { 
  49.                     Thread.sleep(100); 
  50.                 }catch(InterruptedException e) { 
  51.                      
  52.                     Message msg = handler.obtainMessage(); 
  53.                     Bundle b = new Bundle(); 
  54.                     b.putInt("state", STATE_ERROR); 
  55.                     msg.setData(b); 
  56.                     handler.sendMessage(msg);  
  57.                      
  58.                 } 
  59.             } 
  60.             Message msg = handler.obtainMessage(); 
  61.             Bundle b = new Bundle(); 
  62.             b.putInt("state", STATE_FINISH); 
  63.             msg.setData(b); 
  64.             handler.sendMessage(msg); 
  65.         } 
  66.          
  67.     } 
  68.  
  69.     // 此处甚至可以不需要设置Looper,因为Handler默认就使用当前线程的Looper
  70.     private final Handler handler = new Handler(Looper.getMainLooper()) {
  71.  
  72.         public void handleMessage(Message msg) { // 处理Message,更新ListView
  73.             int state = msg.getData().getInt("state"); 
  74.             switch(state){ 
  75.                 case STATE_FINISH: 
  76.                     dismissDialog(PROGRESS_DIALOG); 
  77.                     Toast.makeText(getApplicationContext(), 
  78.                             "加载完成!"
  79.                             Toast.LENGTH_LONG) 
  80.                          .show(); 
  81.  
  82.                     adapter = new ArrayAdapter<String>(getApplicationContext(), 
  83.                             android.R.layout.simple_list_item_1, 
  84.                             data ); 
  85.                              
  86.                     setListAdapter(adapter); 
  87.  
  88.                     break
  89.  
  90.                 case STATE_ERROR: 
  91.                    dismissDialog(PROGRESS_DIALOG); 
  92.                    Toast.makeText(getApplicationContext(), 
  93.                            "处理过程发生错误!"
  94.                            Toast.LENGTH_LONG) 
  95.                         .show(); 
  96.  
  97.                    adapter = new ArrayAdapter<String>(getApplicationContext(), 
  98.                            android.R.layout.simple_list_item_1, 
  99.                            data ); 
  100.                             
  101.                       setListAdapter(adapter); 
  102.  
  103.                       break
  104.  
  105.                default
  106.  
  107.             } 
  108.         } 
  109.     }; 
  110.  
  111.  
  112.     private ArrayAdapter<String> adapter; 
  113.     private ArrayList<String> data; 
  114.  
  115.     private static final int PROGRESS_DIALOG = 1
  116.     private static final int STATE_FINISH = 1
  117.     private static final int STATE_ERROR = -1

这个例子,我自己写完后觉得还是有点乱,要稍微整理才能看明白线程间交互的过程以及数据的前后变化。随后了解到AsyncTask类,相应修改后就很容易明白了!

 

2.3 AsyncTask

AsyncTask版:
  1. ((Button) findViewById(R.id.load_AsyncTask)).setOnClickListener(new View.OnClickListener(){ 
  2.  
  3.     @Override 
  4.     public void onClick(View view) { 
  5.         data = null
  6.         data = new ArrayList<String>(); 
  7.  
  8.         adapter = null
  9.  
  10.         //显示ProgressDialog放到AsyncTask.onPreExecute()里 
  11.         //showDialog(PROGRESS_DIALOG); 
  12.         new ProgressTask().execute(data); 
  13.     } 
  14. }); 
  15.  
  16. private class ProgressTask extends AsyncTask<ArrayList<String>, Void, Integer> { 
  17.  
  18. /* 该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作,如在界面上显示一个进度条。*/ 
  19. @Override 
  20. protected void onPreExecute() { 
  21.     // 先显示ProgressDialog
  22.     showDialog(PROGRESS_DIALOG); 
  23.  
  24. /* 执行那些很耗时的后台计算工作。可以调用publishProgress方法来更新实时的任务进度。 */ 
  25. @Override 
  26. protected Integer doInBackground(ArrayList<String>... datas) { 
  27.     ArrayList<String> data = datas[0]; 
  28.     for (int i=0; i<8; i++) { 
  29.         data.add("ListItem"); 
  30.     } 
  31.     return STATE_FINISH; 
  32.  
  33. /* 在doInBackground 执行完成后,onPostExecute 方法将被UI thread调用, 
  34.  * 后台的计算结果将通过该方法传递到UI thread. 
  35.  */ 
  36. @Override 
  37. protected void onPostExecute(Integer result) { 
  38.     int state = result.intValue(); 
  39.     switch(state){ 
  40.     case STATE_FINISH: 
  41.         dismissDialog(PROGRESS_DIALOG); 
  42.         Toast.makeText(getApplicationContext(), 
  43.                 "加载完成!"
  44.                 Toast.LENGTH_LONG) 
  45.              .show(); 
  46.  
  47.         adapter = new ArrayAdapter<String>(getApplicationContext(), 
  48.                 android.R.layout.simple_list_item_1, 
  49.                 data ); 
  50.                  
  51.         setListAdapter(adapter); 
  52.  
  53.         break
  54.          
  55.     case STATE_ERROR: 
  56.        dismissDialog(PROGRESS_DIALOG); 
  57.        Toast.makeText(getApplicationContext(), 
  58.                "处理过程发生错误!"
  59.                Toast.LENGTH_LONG) 
  60.             .show();
  61.  
  62.        adapter = new ArrayAdapter<String>(getApplicationContext(), 
  63.                android.R.layout.simple_list_item_1, 
  64.                data );
  65.  
  66.           setListAdapter(adapter);
  67.  
  68.           break;
  69.  
  70.    default:
  71.  
  72.    }
  73. }

    Android另外提供了一个工具类:AsyncTask。它使得UI thread的使用变得异常简单。它使创建需要与用户界面交互的长时间运行的任务变得更简单,不需要借助线程和Handler即可实现。

    1)  子类化AsyncTask
    2)  实现AsyncTask中定义的下面一个或几个方法
         onPreExecute() 开始执行前的准备工作;
         doInBackground(Params...) 开始执行后台处理,可以调用publishProgress方法来更新实时的任务进度;
         onProgressUpdate(Progress...)  在publishProgress方法被调用后,UI thread将调用这个方法从而在界面上展示任务的进展情况,例如通过一个进度条进行展示。
         onPostExecute(Result) 执行完成后的操作,传送结果给UI 线程。
 
         这4个方法都不能手动调用。而且除了doInBackground(Params...)方法,其余3个方法都是被UI线程所调用的,所以要求:
        1) AsyncTask的实例必须在UI thread中创建;
        2) AsyncTask.execute方法必须在UI thread中调用;
        
    同时要注意:该task只能被执行一次,否则多次调用时将会出现异常。而且是不能手动停止的,这一点要注意,看是否符合你的需求!
 
    在使用过程中,发现AsyncTask的构造函数的参数设置需要看明白:AsyncTask<Params, Progress, Result>
    Params对应doInBackground(Params...)的参数类型。而new AsyncTask().execute(Params... params),就是传进来的Params数据,你可以execute(data)来传送一个数据,或者execute(data1, data2, data3)这样多个数据。
    Progress对应onProgressUpdate(Progress...)的参数类型;
    Result对应onPostExecute(Result)的参数类型。
    当以上的参数类型都不需要指明某个时,则使用Void,
分享到:
评论

相关推荐

    Android开发中的多线程编程技术

    在Android应用开发中,多线程技术是必不可少的,它能帮助开发者实现高效的代码执行,提升用户体验,并确保应用程序的响应性。本资源包主要聚焦于Android平台上的多线程编程,包括理论概念、最佳实践以及实际应用案例...

    android 线程通信学习

    本教程将深入探讨Android线程通信的基本概念、常用方法以及如何通过Demo来实践这些技术。 一、Android线程基础 Android系统的主要线程被称为“主线程”或“UI线程”,负责处理用户界面的交互事件,如触摸事件、...

    Android-android简单的链式线程切换工具类简单适用可用于学习线程相关知识

    本文将深入探讨由用户分享的"ThreadUtils"工具类,它为Android开发者提供了一种简单的链式线程切换方法,有助于理解和应用线程相关知识。 首先,让我们了解Android中的线程模型。主线程,也称为UI线程,负责处理与...

    android多线程管理

    在Android开发中,多线程管理是至关重要的技术,它涉及到应用的性能、用户体验以及资源的有效利用。...通过以上知识点的学习和实践,开发者可以有效地管理和优化Android应用的多线程,提升应用性能和用户体验。

    Android多线程分段下载源码

    这个"Android多线程分段下载源码"实例是一个很好的学习资源,它实现了文件的分块下载,并允许用户自定义线程数来控制下载速度和效率。下面我们将详细探讨这一技术。 首先,我们要理解什么是分段下载。传统的单线程...

    Delphi XE5例子中的一个Android线程使用的代码AnonymousThread.rar

    通过这个"AnonymousThread"示例,你可以学习到如何在Delphi XE5中创建和管理Android平台的线程,以及如何处理线程间的同步和通信,这对于开发高效、稳定的跨平台应用程序至关重要。实践这些概念,你的Delphi Android...

    Android 线程+View的使用

    在Android开发中,线程和View的...通过分析压缩包中的"08ThreadCtrlView"文件,我们可以深入学习和实践这些知识,进一步提升对Android多线程和UI更新的理解。在项目中灵活运用这些技术,能够提高应用的性能和用户体验。

    android 单线程 多线程下载

    在Android开发中,数据的加载和处理经常涉及到线程的使用。本文主要探讨的是如何在Android平台上实现单线程和多线程下载,这是一项重要的技术,尤其在处理大文件或者需要后台持续运行的任务时。我们将从源码分析、...

    android多线程demo(很清晰很详细)

    通过对这个demo的深入学习,学生能更好地理解Android多线程的工作原理和实践技巧。 总结来说,Android多线程的掌握对于开发者优化应用性能和提升用户体验至关重要。通过分析这个详细的demo,学生们可以逐步了解并...

    Android----线程实现图片移动

    在Android开发中,图片动态...通过分析和学习这个示例,你可以更好地理解和掌握如何在Android中利用线程实现图片的动态效果。在实际开发中,可以根据具体需求进行调整,例如添加动画的缓动函数以实现更平滑的移动效果。

    android多线程学习

    在Android开发中,多线程是一项至关重要的技术,它使得应用程序能够同时执行多个任务,提升用户体验,特别是对于处理耗时操作如网络请求、大数据计算或长时间的IO操作时。本教程将带你深入理解Android中的多线程,并...

    android多线程下载

    在Android中,我们可以利用Java的多线程机制,如`Thread`或`ExecutorService`,以及`AsyncTask`(对于UI相关的操作)来实现多线程下载。每个线程负责下载文件的一个部分,下载进度需要被记录以便于断点续传。 以下...

    android 线程入门教程

    根据提供的文件信息,我们可以提炼出Android线程入门教程的相关知识点。本教程主要面向Android开发新手,着重介绍Android中的线程机制,包括UI线程模型以及线程间通信的方法。 知识点一:Android UI单线程模型 ...

    Android 多线程学习资料

    总的来说,Android多线程机制的核心在于通过主线程的Looper、MessageQueue和Handler进行线程间通信。这种方式保证了UI线程的安全性,避免了因其他线程直接操作UI而导致的不安全情况。理解并熟练运用这些概念对于开发...

    android多线程断点下载

    通过阅读和学习这些代码,可以加深对Android多线程断点下载的理解,并且可以直接应用到实际项目中。 总之,Android多线程断点下载是提高用户体验的重要手段,封装好的接口可以让开发者更专注于业务逻辑,而不是复杂...

    android 多线程下载源代码

    本资源提供的"android 多线程下载源代码"是一个很好的学习资料,可以帮助开发者理解并实现这一功能。 多线程下载的基本原理是将一个大文件分割成多个小部分,然后在一个线程池中创建多个线程,每个线程负责下载文件...

    Android多线程下载实现方案

    通过安装`demo.apk`,你可以直观地看到多线程下载的运行效果,同时也可以参考代码学习具体的实现方法,这对于理解和掌握Android多线程下载技术非常有帮助。 总结,Android多线程下载是提升用户体验的重要手段,通过...

    Android多线程任务优化2:实现后台预读线程

    在Android应用开发中,性能优化是一项至关重要的任务,特别是在处理数据加载、网络请求以及大量计算时。本篇文章将深入探讨如何通过实现后台预读...持续学习和实践,不断优化,才能打造更加流畅、高效的Android应用。

    Android-dialog库可以在任意类内调用子线程或ui线程内均可显示

    Android-dialog库针对这些需求进行了优化,提供了更简洁的API,允许开发者在子线程中预处理Dialog的相关数据,然后在合适的时候切换到主线程进行显示,避免了阻塞UI。这种设计遵循了Android的异步编程原则,使得代码...

    android studio多线程下载

    在Android开发中,多线程下载是一项常见的技术,特别是在处理大文件或网络资源时,为了提高下载速度和用户体验,开发者通常会采用多线程来分块下载数据。Android Studio作为官方推荐的Android集成开发环境,提供了...

Global site tag (gtag.js) - Google Analytics