lin20080410的专栏

从站在巨人的肩上,向成为巨人迈进... 互相学习!

Android 中进程、线程的概念

一,Android 进程和线程

进程-Process 是程序的一个运行实例,以区别于“程序”这一静态的概念,线程-Thread则是cpu调度的基本单位。

一个进程的创建是通过Process.start()来完成的,其中的参数可以定制进程启动后最先执行的线程,通常会指定为ActivityThread,所以一个进程起来后先运行的就是这个主线程。Process会通过socket把创建进程的请求发给zygote,最终由zygote来fork一个新的进程。

Android中的程序和进程具体是个什么概念呢?

对于Android的应用程序来说,通常接触的都是Activity,Service,Receive,ContentProvider等组件,四大组件,它们不能算是完整的进程实例,最多只能算是进程的组成部分,从AndroidManifest.xml中可以看出,在这些组件的最外围还有一个application 标签,四大组件只是 application 的零件。我们以一个有IDE向导生成的简单的工程来看看一个应用中的进程和线程。

在自动生成的源码中MainActivity.java中的onCreate()函数入口处加上断点,如图:


那么,这个Activity启动后,会产生几个Thread 呢,如图:


除了我们熟悉的main thread外,还有2个Binder Thread,因为应用程序启动过程中需要跟系统进程ActivityManagerService、WindowManagerService等通信,需要Binder线程。那么主线程是怎么产生?可以看到主线程是有ZygoteInit启动,经过一系列的调用最终执行了Activity本身的onCreate()函数,从这里知道,主线程就是ActivityThread。

frameworks/base/core/java/android/app/ActivityThread.java

public static void main(String[] args) {

Looper.prepareMainLooper(); 主线程会调用这个函数,普通线程调用prepare()

ActivityThread thread = new ActivityThread();

  thread.attach(false); 这个函数将于windowManagerService 建立联系,因为Activity是有界面显示的

if (sMainThreadHandler == null) {

  sMainThreadHandler = thread.getHandler();主线程对应的handler

}

 Looper.loop(); 主循环开始

}

在ActivityThread内部,还有一个ApplicationThread,这个ApplicationThread是应用进程跟ActivityManagerService进行跨进程通信的桥梁,比如AMS启动一个Activity,实际是先由ApplicationThread的scheduleLaunchActivity,然后到ActivityThread的performLaunchActivity。

实际上,所有应用程序的主线程都是Activity Thread,这里使用的组件是Activity,如果换成Service也是一样的,并且在一个应用程序中,主线程只有一个,对于同一个AndroidManifest.xml中定义的组件,除非有特别的指明(可以指定一个组件运行在某个进程空间,使用android:process属性,也可以在<application>标签中加入这个属性,指明想要依存的进程环境),否则它们都运行于同一个进程中。

二,Handler,MessageQueue,Runnable,Looper

1,Handler 代码路径:framework/base/core/java/android/os/Handler.java

public class Handler{

final MessageQueue mQueue;

final Looper mLooper;

IMessenger mMessenger;

final Callback mCallback;。。。

}

这里提到的几个主要元素的关系,简单说就是:Looper 不断从MessageQueue中取出消息message,然后交给Handler来处理。

每个Thread只对应一个Looper

每个Looper只对应一个MessageQueue

每个MessageQueue中有N个Message

每个Message最多指定一个Handler来处理事件

每个Thread可以对应多个Handler

Handler是经常会使用到的一个类,主要有两个方面的作用:一是处理Message,二是将某个message压入messageQueue中。Looper从MessageQueue中取出一个Message后,首先会调用Handler.dispatchMessage进行消息派发,默认的派发流程:

   /**

     *Handle system messages here.

     */

    publicvoid dispatchMessage(Message msg) {

        if(msg.callback != null) {

           handleCallback(msg);

        }else {

           if (mCallback != null) {

               if (mCallback.handleMessage(msg)) {

                    return;

               }

           }

           handleMessage(msg);

        }

    }

由这个函数看出,Handler的扩展子类可以通过重载dispatchMessage或handleMessage来改变它的默认行为。

处理优先级是消息本身的callback,最有优先权,其次是handler的callback,

其中msg的callback是在其生成Message对象时设置的,比如post(Runnable r)时,会先把runnable转成message,同时把runnable设置为msg的callback;

handler的callback是在实例化handler对象时。作为Handler的构造函数的参数,传入的一个实现了Handler.Callback的对象。


把一个消息压入消息队列的相应功能函数:

public final boolean post(Runnable r)

 public final boolean postAtTime(Runnable r, long uptimeMillis)

 public final boolean sendMessage(Message msg)

public final boolean sendMessageDelayed(Message msg, long delayMillis)。。。

以第一个函数为例:

    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }首先要把Runnable 对象,封装成一个Message,接着通过对应的send函数推送到messageQueue中,

    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }这里将Runnable对象设置为Message的回调。

整个过程中,message通过handler压入messagequeue中,然后由looper从messagequeue中取出消息,还是交给了handler来处理,为什么不直接操作,而是大费周折的转了这么一圈?这里体现了程序设计的一个良好习惯“有序性”。

2,MessageQueue,源码路径:frameworks/base/core/java/android/os/MessageQueue.java

就是一个消息队列,具有“队列”的一些常规操作:

新建队列:由本地方法nativeInit来完成。

元素入队: boolean enqueueMessage(Message msg, long when)

元素出队:Message next()

删除元素:void removeMessages(Handler h, int what, Object object)

其中有一个接口IdleHandler,

    public static interface IdleHandler {
        boolean queueIdle();
    }
这是一个回调接口,当线程队列中没有消息时,线程会进入block状态,这时会调用其queueIdle()方法,如果返回值为true,表示这个idlehandler将保持active状态,否则会被删除,如果你希望在线程处于空闲时,要做什么事情,可以实现这个接口,然后添加到消息队列中。比如说GC的执行,可能就需要在线程空闲时执行。


3,Looper,源码路径:frameworks/base/core/java/android/os/

从Looper的源码看出,Looper中包含了一个MessageQueue队列。

使用Looper的线程,有三个步骤:

1)Looper的准备工作(prepare

2)创建处理消息的Handler

3)Looper开始运作(loop)

首先:Looper.prepare() Looper中有一个很重要的成员变量,   

 // sThreadLocal.get() will return null unless you've called prepare().

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();ThreadLocal对象是一个特殊的全局变量,因为它的“全局”性只限于自己所在的线程,而外界的线程(即使在同一进程)一概无法访问到他,这从侧面说明,每个线程的Looper都是独立的。它实际就是针对每个Thread的特定数据存储空间。

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

这个函数里的判断保证了一个Thread只会有一个Looper实例存在,sThreadLocal创建了一个只针对当前线程的Looper对象。

在使用Looper的线程里,肯定会创建Handler对象,所以mHandler是Thead实现类的成员变量,那么,Handler如何与Looper关联起来的呢?从Handler的构造函数分析:

public Handler()

public Handler(Callback callback)

public Handler(Looper looper, Callback callback) 

public Handler(Looper looper, Callback callback, boolean async)

之所以有这么多构造函数,是因为Handler有如下内部变量需要初始化:

 final MessageQueue mQueue;

 final Looper mLooper;

 final Callback mCallback;

以其中一个构造函数为例:

    public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }
        mLooper = Looper.myLooper();  //
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

  mLooper = Looper.myLooper();  还是通过sThreadLocal.get来获取当前线程中的Looper实例。

mQueue = mLooper.mQueue; mQueue是Looper跟handler之间沟通的桥梁。这样Handler和Looper,MessageQueue就联系起来了,后续Handler执行post/send系列函数时,会将消息投递到mQueue也即是mLooper.mQueue中。

3,UI主线程 Activitythread

源码路径:frameworks/base/core/java/android/app/ActivityThread.java

   public static void main(String[] args) {
  ...
        Looper.prepareMainLooper();


        ActivityThread thread = new ActivityThread();
        thread.attach(false);


        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

注意区别,普通线程调用prepare(),这里调用prepareMainLooper(),主线程的Handler是从当前线程中获得的thread.getHandler();。

    public static void prepareMainLooper() { //这个是Looper.java中的方法
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }prepareMainLooper也需要调用prepare,参数false表示该线程不允许退出。经过prepare后,myLooper就得到一个本地线程<ThreadLocal>的Looper对象,然后赋值给sMainLooper,从这里看,主线程和其他线程的Looper对象没有本质的区别。

作为主线程,它这么做的目的,就是其他线程如果要获取主线程的Looper,只需要调用getMainLooper()即可。

作为普通线程,它生成的Looper对象,只能在线程内通过myLooper()访问。

在来看下Looper.loop的是实现,也是Looper.java中的方法

 public static void loop() {
        final Looper me = myLooper(); 函数myLooper()则是调用sThreadLocal.get()来获取与之匹配的Looper实例,其实就是取出在prepare中创建的那个Looper对象。
        final MessageQueue queue = me.mQueue; //Looper中自带了一个MessageQueue

        for (;;) {
            Message msg = queue.next(); // might block从MessageQueue中取出消息,可能会阻塞,如果当前消息队列中没有消息,说明线程要退出了
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            msg.target.dispatchMessage(msg); 开始分发消息,这里的target就是一个handler,所以dispatch最终调用的是handler中的处理函数

            msg.recycleUnchecked(); 消息处理完毕,进行回收
        }
    }

在来看一个函数,Looper的构造函数:

    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed); //new 了MessageQueue,也就是Looper在创建是,消息队列也同时被创建出来
        mThread = Thread.currentThread(); Looper与当前线程建立了对应关系
    }

4,Thread类

1)Thread类的内部原理,源码路径  libcore/libart/src/main/java/java/lang/Thread.java

public class Thread implements Runnable{

Thread实现了Runnable,也就是说线程是“可执行的代码”。

libcore/libuni/src/main/java/java/lang/Runnable.java  Runnable是一个抽象的接口,唯一的方法就是run方法

public interface Runnable {
    /**
     * Starts executing the active part of the class' code. This method is
     * called when a thread is started that has been created with a class which
     * implements {@code Runnable}.
     */
    public void run();
}

通常我们是这样使用Thread的:

方法1,定义一个类继承自Thread,重写它的run方法,然后调用start

MyThread thr= new Mythread();

thr.start();

方法2,直接实现Runnable,

new Thread(Runnable target).start();

两种方法都是通过start启动,它会间接调用run方法,

    public synchronized void start() {
        checkNotStarted();
        hasBeenStarted = true;
        nativeCreate(this, stackSize, daemon); 这里是真正创建一个cpu线程的地方,在此之前,一直都是运行在“老线程”中,实际上在新线程中运行的只有Run方法。
    }

2)Thread的休眠与唤醒,来看一下与此相关的控制方法:

首先是:wait notify notifyAll,这三个函数是Object类定义的,意味着它们是任何类的共有“属性”,下面的方法是Handler.java中的内部类:BlockingRunnable的,涉及到等待时,会调用它

        public boolean postAndWait(Handler handler, long timeout) {
            if (!handler.post(this)) {
                return false;
            }
            synchronized (this) {
                if (timeout > 0) {
                    final long expirationTime = SystemClock.uptimeMillis() + timeout;
                    while (!mDone) {
                        long delay = expirationTime - SystemClock.uptimeMillis();
                        if (delay <= 0) {
                            return false; // timeout
                        }
                        try {
                            wait(delay);
                        } catch (InterruptedException ex) {
                        }
                    }
                } else {
                    while (!mDone) {
                        try {
                            wait();
                        } catch (InterruptedException ex) {
                        }
                    }
                }
            }
            return true;
        }这个函数在Handler中的作用就是“投递并等待”,所以函数开头就把一个runnable(this)post到了handler所在的looper中。如果timeout大于0,说明是有条件限制的等待,这样可以避免异常时间下的“死等”;如果timeout等于0,无限期等待,直到有人来唤醒他。线程进入等待调用的是wait(),唤醒他就是notify/notifyAll,那么什么时候执行的唤醒操作呢?

    private static final class BlockingRunnable implements Runnable {
        public BlockingRunnable(Runnable task) {
            mTask = task;
        }

        @Override
        public void run() {
            try {
                mTask.run();
            } finally {
                synchronized (this) {
                    mDone = true;
                    notifyAll(); BlockingRunnable 对象在执行run函数时,同时也做了个特殊的操作,通知所有在等待的人,我运行OK了。
                }
            }
        }

然后,interrupt,如果说wait是一种“自愿”的行为,那么interrupt就是被迫的了,调用一个线程的interrupt这个方法,就是中断它的执行过程。

join方法的几个原型:

 public final void join()

 public final void join(long millis)

public final void join(long millis, int nanos)

比如:Thread t1;Thread t2;

t1.start();

t1.join();

t2.start(); 它希望的目的是只有当t1线程执行完成时,才接着执行后面的t2.start(),这样就保证了两个线程的顺序执行。带有参数的join多了一个限制,假如在规定的时间内t1没有执行完成,那么会继续执行后面的语句,防止无限等待。

最后,sleep方法,它和wait类似,都属于自愿的行为,只是wait是等待某个object,而sleep则是等待时间,一旦设置的时间到了就会被唤醒。










阅读更多
版权声明:笔记记录,互相学习,不足之处,欢迎指正! https://blog.csdn.net/lin20044140410/article/details/51062088
文章标签: android 进程 线程
个人分类: android开发
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭