【Android开发网上的一些重要知识点[经验分享]。。】

熊猫儿

深入浅出Android的多线程
1.在Android中，线程的类型：

a．有消息循环的线程；
b．无消息循环的线程；
2.线程分为：

a.UI线程；
b.子线程；
3.主线程与子线程的区别：

只要是关于UI相关的东西，就不能放在子线程中处理，因为子线程是不能操作UI的，只能进行数据、系统等其他非UI的操作
4.有消息循环的线程一般都会有一个Looper

5.主线程（UI线程）就是一个消息循环的线程。

6.Handle如何初始化：

Handle的初始化函数（构造函数），
1．如果没有参数，那么他就默认使用的是当前的Looper；
2．如果有Looper参数，就是用对应的线程的Looper。
7.如何获得线程的Looper：

Looper.myLooper();      //获得当前线程的Looper
Looper.getMainLooper () //获得UI线程的Lopper
8.消息处理过程：

a.发送消息；
b.获取消息；
c.处理消息；
9.Handler在应该在哪个线程中创建：

handler应该由处理消息的线程创建；
也就是说，如果handler的函数handleMessage里处理的是UI的消息，也就是更新界面的事情，那么该handler需要在主线程中创建；
10.Handler的作用：

1.是把消息加入特定的（Looper）消息队列中；
2.分发消息；
3.处理该消息队列中的消息；
11.handler与创建它的线程之间的关系：

handler与创建它的线程相关联，而且也只与创建它的线程相关联。
handler运行在创建它的线程中，所以，如果在handler中进行耗时的操作，会阻塞创建它的线程。
12.handle运行在哪个线程中（主线程还是子线程）：

handler运行在创建它的线程中，所以，如果在handler中进行耗时的操作，会阻塞创建它的线程。

熊猫儿

13.结合具体代码，详解Handle的创建：

package com.android.tutor;  
import java.util.Timer;  
import java.util.TimerTask;  
import android.app.Activity;  
import android.os.Bundle;  
import android.os.Handler;  
import android.os.Message;  
public class HandlerDemo extends Activity {  
      
    //title为setTitle方法提供变量,这里为了方便我设置成了int型  
    private int title = 0;  
      
    private Handler mHandler = new Handler(){  
         
        public void handleMessage(Message msg) {  
            switch (msg.what) {  
            case 1:  
                updateTitle();  
                break;  
            }  
        };  
    };  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
         
        Timer timer = new Timer();  
        timer.scheduleAtFixedRate(new MyTask(), 1, 5000);  
    }  
         
    private class MyTask extends TimerTask{  
        @Override  
        public void run() {  
              
            Message message = new Message();  
            message.what = 1;  
            mHandler.sendMessage(message);  
              
        }     
    }  
      
      
    public void updateTitle(){  
         
        setTitle("Welcome to Mr Wei's blog " + title);  
        title ++;  
    }  
}  

上面的代码，直接在主线程中定义Handler成员。在子线程中通过主线程的handler向主线程发送消息。其使用步骤如下：
1、在主线程中定义handler，并为这个handler实现handleMessage方法。
2、在子线程中调用主线程的handler，通过其sendMessage方法发送消息。
Notes：
1.HandlerDemo对应一个主线程；
因为：当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程)；
所以：
在HandlerDemo类中定义handler成员变量，就对应的是：在主线程中定义handler；
2.子线程就是MyTask，在MyTask的run成员函数中调用mHandler.sendMessage(message),
就对应的是：在子线程中调用主线程的handler，通过其sendMessage方法发送消息；
3. updateTitle()属于更新UI操作，只能在主线程中操作，而handler是在主线程中创建，所以符合：UI更新只能在主线程中操作的原则；

熊猫儿

14.Android消息循环是针对线程的：

每个线程都可以有自己的消息队列和消息循环；
Android系统的消息队列和消息循环都是针对具体线程的；
一个线程可以存在（当然也可以不存在）一个消息队列和一个消息循环 （Looper）；
特定线程的消息只能分发给本线程，不能进行跨线程，跨进程通讯。
15.创建的工作线程默认是没有消息循环和消息队列的：

16.如何让创建的工作线程具有：消息循环和消息队列呢？


17. Activity是一个UI线程，运行于主线程中

Activity是一个UI线程，运行于主线程中，Android系统在启动的时候会为Activity创建一个消息队列和消息循环（Looper）。
详细实现请参考ActivityThread.java文件。
18.子线程的代码示例：

class LooperThread extends Thread {
public Handler mHandler;

public void run() {
Looper.prepare();

mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};

Looper.loop();
}
}

19.一个子线程如何把消息放入主线程的消息队列中？

通过Handle对象，只要Handler对象以主线程的Looper创建，那么调用 Handler的sendMessage等接口，将会把消息放入队列都将是放入主线程的消息队列。
并且将会在Handler主线程中调用该handler 的handleMessage接口来处理消息。
20. handler对象的handleMessage接口：

handler对象的handleMessage接口将会在主线程中调用。
在这个函数可以放心的调用主线程中任何变量和函数，进而完成更新UI的任务
21.Handle用途：

如果通过工作线程刷新界面，推荐使用handler对象来实现。
22.handler对象使用要点：

1.handler对象在主线程中构造完成（并且启动工作线程之后不要再修改之，否则会出现数据不一致），然后在工作线程中可以放心的调用发送消息SendMessage等接口；
2. 除了所述的hanlder对象之外的任何主线程的成员变量如果在工作线程中调用，仔细考虑线程同步问题。
如果有必要需要加入同步对象保护该变量。

熊猫儿

2.子线程的代码示例之二：

package com.simon;

import android.app.Activity;
import android.os.Bundle;
import android.os.Message;
import android.util.Log;
import android.os.Handler;

public class MyHandler extends Activity {
static final String TAG = “Handler”;
Handler h = new Handler(){
public void handleMessage (Message msg)
{
switch(msg.what)
{
case HANDLER_TEST:
Log.d(TAG, “The handler thread id = ” + Thread.currentThread().getId() + “/n”);
break;
}
}
};

static final int HANDLER_TEST = 1;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.d(TAG, “The main thread id = ” + Thread.currentThread().getId() + “/n”);

new myThread().start();
setContentView(R.layout.main);
}

class myThread extends Thread
{
public void run()
{
Message msg = new Message();
msg.what = HANDLER_TEST;
h.sendMessage(msg);
Log.d(TAG, “The worker thread id = ” + Thread.currentThread().getId() + “/n”);
}
}
}

说明：
1.MyHandler是Activity的派生，是主线程；
2.myThread是子线程，工作线程；
3.在子线程的run函数中调用h.sendMessage(msg)发送消息；
4.Handler对象在主线程中创建；
Handler h = new Handler()
5.在onCreate中函数创建子线程；
new myThread().start()

熊猫儿

熊猫儿

深入浅出Android消息系统之一
1.VC6.0 MFC消息机制

通过PreTranslateMessage处理消息；
2.Activity内嵌的消息处理机制有：
a.onKeyDown；
b.各式各样的lister,如onKeyDownListener；
3.有哪些工作必须通过消息分发处理机制来完成呢：
a.事件的定时触发；
b.异步的循环事件的处理；
c.高耗时的工作；
4.Handler处理哪个线程下的消息：

默认情况下，Handler接受的是当前线程下的消息循环实例
5.一个消息循环可以被多个对象分发与处理

一个消息循环可以被当前线程中的多个对象来分发，来处理（在UI线程中，系统已经有一个Activity来处理了，你可以再起若干个Handler来处理...）。
6. Android的CPU分配的最小单元：

线程
7.Handler与Thread的关系：
Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应的；
8.Runnable与Thread之间的关系：

Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个线程；
9.Thread(HandlerThread)的作用是什么？

HandlerThread顾名思义就是可以处理消息循环的线程，他是一个拥有Looper的线程，可以处理消息循环。
10.Handler是在UI线程之内运行的，并没有新建线程：

在UI线程（主线程）中，有如下代码：
mHandler=new Handler();

mHandler.post(new Runnable(){
void run(){
       //执行代码...
     }

});
这个线程其实是在UI线程之内运行的，并没有新建线程。

熊猫儿

11.常见的新建线程的方法是：
方法一：
Thread thread = new Thread();
thread.start();
方法二:
HandlerThread thread = new HandlerThread("string");
thread.start();
12.主线程就是UI线程；

13.UI线程何时创建：

当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程)
14.主线程的作用：

主线程为管理界面中的UI控件，进行事件分发, 比如说, 你要是点击一个Button,Android会分发事件到Button上，来响应你的操作。
15.如果把耗时的工作，放在主线程中处理，有什么后果？

如果放在主线程中的话，界面会出现假死现象, 如果5秒钟还没有完成的话，会收到Android系统的一个错误提示   "强制关闭".
16.有哪些是耗时的工作：

a.联网读取数据；
b.读取本地的一个大文件；
c.硬件初始化；
17.如果遇到耗时的工作，如何处理？

需要把这些耗时的操作放在一个子线程中
18.更新UI只能在主线程中更新；

Notes：主线程就是UI线程；
19. Handler的作用：

Handler的作用：
1.接受子线程传过来的Message对象(里面包含数据)；
Notes：子线程用sedMessage()方法传递；
2.把这些消息放入主线程队列中，
3.配合主线程进行更新UI。；
20.Handler与Thread如何传递数据：

Handler与子线程可以通过Message对象来传递数据。

熊猫儿

011年Android Activity生命周期学习笔记
一．启动Activity：
会依次调用如下三个函数：
1.onCreate;
2.onStart;
3.onResume;

二．按BACK键：
该Activity将结束，即Destroy销毁掉，会依次调用如下三个函数：
1.onPause；
2.onStop；
3.onDestroy；

三．按HOME键：
打开其他应用程序，如音乐应用程序；
此时该Activity,会进入不可见状态，会调用如下两个函数：
1.onPause;
2.onStop;
注意：该Activity仅仅不可见，但没有别销毁，因为没有调用onDestroy函数；

四．再次按HOME键，进入该 Activity时：
意即再次显示该Activity时；
会调用如下三个函数：
1.onRestart;
2.onStart;
3.onResume;

五．Activity生命周期图：

1.调用onResume函数，意味着：
该activity处于激活状态，是可见的；
2.调用了onPause函数，意味着：
该activity不可见了，用户看不到了；
3.调用onRestart 函数，意味着：
该activity从后台运行变成前台运行，是可见的；
4. 调用onDestroy 函数，意味着：
该activity对象被销毁，即内存中不存在该对象。

熊猫儿

2011年Android IPC进程间通讯机制学习笔记之 一
一.Linux系统进程间通信有哪些方式？
1.socket；
2.name pipe命名管道；
3.message queue消息队列；
4.singal信号量；
5.share memory共享内存；
二.Java系统的通信方式是什么？
1.socket;
2.name pipe;
三.Android系统通信方式是什么？
Binder 通信；
四.Binder通信的优势是什么？
高效率
五.Binder通信的特点是什么？
是同步，而不是异步；
六.Binder通信是如何实现的？
1.Binder通信是通过linux的binder driver来实现的，
2.Binder通信操作类似线程迁移(thread migration)，两个进程间IPC看起来就象是一个进程进入另一个进程执行代码然后带着执行的结果返回；
3.Binder的用户空间为每一个进程维护着一个可用的线程池，线程池用于处理到来的IPC以及执行进程本地消息，Binder通信是同步而不是异步。
七. Android中的 Binder通信实现要点：

1. Android中的Binder通信是基于Service与Client的工作模型的；
2. 所有需要IBinder通信的进程都必须创建一个IBinder接口；
3. 系统中有一个进程管理所有的system service：
4. Android不允许用户添加非授权的System service；
5. 现在源码开放了，我们可以修改一些代码来实现添加底层system Service的目的；
6. 对用户程序来说，我们也要创建server,或者Service用于进程间通信；
7. ActivityManagerService管理JAVA应用层所有的service创建与连接(connect),disconnect；
8. 所有的Activity也是通过这个service来启动，加载的；
9. ActivityManagerService也是加载在Systems Servcie中的；
八.Android的 Service工作流程
1.Android虚拟机启动之前系统会先启动service Manager进程；2.service Manager打开binder驱动，并通知binder kernel驱动程序这个进程将作为System Service Manager；
3.然后该进程将进入一个循环，等待处理来自其他进程的数据。4.用户创建一个System service后，通过defaultServiceManager得到一个远程ServiceManager的接口，通过这个接口我们可以调用addService函数将System service添加到Service Manager进程中；
5.然后client可以通过getService获取到需要连接的目的Service的IBinder对象，这个IBinder是Service的BBinder在binder kernel的一个参考，
6.所以service IBinder 在binder kernel中不会存在相同的两个IBinder对象，每一个Client进程同样需要打开Binder驱动程序。对用户程序而言，我们获得这个对象就可以通过binder kernel访问service对象中的方法。
7.Client与Service在不同的进程中，通过这种方式实现了类似线程间的迁移的通信方式，对用户程序而言当调用Service返回的IBinder接口后，访问Service中的方法就如同调用自己的函数。

熊猫儿

upup