android 调用线程方法有哪些,Android建立方法调用的线程队列

本文主要介绍，android在Activity把某个类的方法执行放进线程队列的模式

先定义一个类Tracker，提供以下公有方法

+getInstance():Tracker

+setContext(Context):void

+showABC():void

Tracker的方法不直接执行，而是通过一个线程调度的类EasyTracer来调度执行

建立一个类TrackedActivity继承Activity，重写几个生命周期的方法，主要在里面加入EasyTracer。

这样就可以实现EasyTracer的生命周期跟Activity一致，使用时不继承Activity而是继承TrackedActivity。

执行Tracker类的方法时用EasyTracer代替，例如

执行showABC()，则用：

EasyTracer.getEasyTracker().showABC();

TrackedActivity类例子：

import android.app.Activity;

import android.os.Bundle;

public class TrackedActivity extends Activity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

EasyTracer.getEasyTracker().setContext(this);

}

@Override

protected void onStart() {

super.onStart();

EasyTracer.getEasyTracker().trackActivityStart(this);

}

@Override

protected void onStop() {

super.onStop();

EasyTracer.getEasyTracker().trackActivityStop(this);

}

}

EasyTracer类：

import android.content.Context;

import android.util.Log;

import java.util.concurrent.LinkedBlockingQueue;

public class EasyTracer {

private static EasyTracer instance;

private Context Context;//当前activity的Context

private Context gaContext;//应用程序的全局Context，唯一的

private Tracker tracker =

Tracker.getInstance();//全局变量，运行于整个程序生命周期

public static EasyTracer getEasyTracker() {

if (instance == null) {

instance = new EasyTracer();

}

return instance;

}

//初始化 tracker

private void initTracker(){

queueToTrackerThreadIfEnabled(new Runnable() {

public void run() {

tracker.setContext(Context);

}

});

}

public void setContext(Context ctx) {

if (ctx == null) {

Log.e(LOG_TAG, "Context cannot be null");

}

Context = ctx;

initTracker();

if (gaContext == null) {// 此处代码全局只执行一次，可用于初始化基础信息

gaContext = ctx.getApplicationContext();

loadParameters();

}

}

private void loadParameters() {

if (trackerThread == null) {

trackerThread = new TrackerThread();

trackerThread.start();

}

}

private

void showABC(){

queueToTrackerThreadIfEnabled(new

Runnable() {

public void run() {

tracker.showABC();

}

});

}

public void trackActivityStart(TrackedActivity

trackedActivity) {

queueToTrackerThreadIfEnabled(new Runnable() {

public void run() {

// 页面创建时要做的事情

}

});

}

public void trackActivityStop(TrackedActivity trackedActivity)

{

queueToTrackerThreadIfEnabled(new Runnable() {

public void run() {

// 页面结束时要做的事情

}

});

}

private final

LinkedBlockingQueue

trackerQueue = new

LinkedBlockingQueue();

private TrackerThread trackerThread;

private Object lock = new Object();

// 把线程插进线程锁队列trackerQueue中

private void queueToTrackerThreadIfEnabled(Runnable r) {

synchronized (lock) {

trackerQueue.add(r);

}

}

// 内部类，一个死循环，不停调出 trackerQueue 中的线程，然后运行之。

private class TrackerThread extends Thread {

TrackerThread() {

super("TrackerThread");// 设置线程名称

}

@Override

public void run() {

while (true) {

Runnable r;

try {

r = trackerQueue.take();// 从队列中移出第一个

r.run();

} catch (InterruptedException e) {

Log.i(LOG_TAG, e.toString());

}

}

}

}

}

生活永不停步......