BlockCanary
核心原理离不开主线程ActivityThread，用到了Handler，Looper；在Looper循环方法，BlockCanary利用了handler原理，在 msg.target.dispatchMessage(msg);的上下方去分别打印方法执行时间，根据时间差去判断dispatchMessage是否产生了耗时的操作，是否有UI卡顿
//将打印类替换成自己的打印类，重写println就能获取消息执行前后的时间
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
//上方下方都是log输出
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
BlockCanary流程分析
初始化
在application中的oncreate方法中
BlockCanary.install(getApplicationContext(), new AppBlockCanaryContext()).start();
public static BlockCanary install(Context context, BlockCanaryContext blockCanaryContext) {
//init方法仅仅做了些赋值操作
BlockCanaryContext.init(context, blockCanaryContext);
//根据用户消息栏通知消息配置是否开启关系来展示blockcanary界面
setEnabled(context, DisplayActivity.class, BlockCanaryContext.get().displayNotification());
return get();
}
public static BlockCanary get() {
if(sInstance == null) {
Class var0 = BlockCanary.class;
synchronized(BlockCanary.class) {
if(sInstance == null) {
sInstance = new BlockCanary();
}
}
}
return sInstance;
}
private BlockCanary() {
//BlockCanary一些重要的实现放在这个内部内中实现
BlockCanaryInternals.setContext(BlockCanaryContext.get());
//BlockCanaryInternals的单例
this.mBlockCanaryCore = BlockCanaryInternals.getInstance();
this.mBlockCanaryCore.addBlockInterceptor(BlockCanaryContext.get());
//通知栏是否开启，release是不显示的
if(BlockCanaryContext.get().displayNotification()) {
//展示页面
this.mBlockCanaryCore.addBlockInterceptor(new DisplayService());
}
}
由上面的代码分析出核心的一些功能在BlockCanary的内部类BlockCanaryInternals中实现
public final class BlockCanaryInternals {
LooperMonitor monitor;
StackSampler stackSampler;
CpuSampler cpuSampler;
private static BlockCanaryInternals sInstance;
private static BlockCanaryContext sContext;
private List<BlockInterceptor> mInterceptorChain = new LinkedList();
public BlockCanaryInternals() {
//dump出我们线程的stack信息，传入主线程以及dump的时间间隔
this.stackSampler = new StackSampler(Looper.getMainLooper().getThread(), (long)sContext.provideDumpInterval());
//dump出CPU的信息
this.cpuSampler = new CpuSampler((long)sContext.provideDumpInterval());
//LooperMonitor很重要，因为通过LooperMonitor来打印dispatchMessage时上
//下的时间
this.setMonitor(new LooperMonitor(new BlockListener() {
//当消息处理时间大于阈值，回调打印主线程调用栈，cpu的使用情况，内存情况等
public void onBlockEvent(long realTimeStart, long realTimeEnd, long threadTimeStart, long threadTimeEnd) {
ArrayList threadStackEntries = BlockCanaryInternals.this.stackSampler.getThreadStackEntries(realTimeStart, realTimeEnd);
if(!threadStackEntries.isEmpty()) {
BlockInfo blockInfo = BlockInfo.newInstance().setMainThreadTimeCost(realTimeStart, realTimeEnd, threadTimeStart, threadTimeEnd).setCpuBusyFlag(BlockCanaryInternals.this.cpuSampler.isCpuBusy(realTimeStart, realTimeEnd)).setRecentCpuRate(BlockCanaryInternals.this.cpuSampler.getCpuRateInfo()).setThreadStackEntries(threadStackEntries).flushString();
LogWriter.save(blockInfo.toString());
if(BlockCanaryInternals.this.mInterceptorChain.size() != 0) {
Iterator var11 = BlockCanaryInternals.this.mInterceptorChain.iterator();
while(var11.hasNext()) {
BlockInterceptor interceptor = (BlockInterceptor)var11.next();
interceptor.onBlock(BlockCanaryInternals.sContext.provideContext(), blockInfo);
}
}
}
}
}, (long)getContext().provideBlockThreshold(), getContext().stopWhenDebugging()));
//删除日志
LogWriter.cleanObsolete();
}
}
stacksampler/cpusampler/start方法
上面分析了install方法，现在分析下start方法
BlockCanary.install(getApplicationContext(), new AppBlockCanaryContext()).start();
public void start() {
if(!this.mMonitorStarted) {
this.mMonitorStarted = true;
//monitor为LooperMonitor
Looper.getMainLooper().setMessageLogging(this.mBlockCanaryCore.monitor);
}
//Looper类中
public void setMessageLogging(@Nullable Printer printer) {
mLogging = printer;
}
}
LooperMonitor类中有个重要的方法println，之后Looper中的日志打印将走这个方法。
class LooperMonitor implements Printer {
public void println(String x) {
if(!this.mStopWhenDebugging || !Debug.isDebuggerConnected()) {
if(!this.mPrintingStarted) {
this.mStartTimestamp = System.currentTimeMillis();
//当前线程运行的总时间，sleep跟wait不会记录这个时间当中
this.mStartThreadTimestamp = SystemClock.currentThreadTimeMillis();
this.mPrintingStarted = true;
//开始dump
this.startDump();
} else {
long endTime = System.currentTimeMillis();
this.mPrintingStarted = false;
//如果message执行后减去执行前的时间大于阈值
if(this.isBlock(endTime)) {
//执行回调
this.notifyBlockEvent(endTime);
}
//停止dump
this.stopDump();
}
}
}
private void startDump() {
if(null != BlockCanaryInternals.getInstance().stackSampler) {
//开启HandlerThread线程处理doSample()方法，doSample()主要是把当前时间
//(key)跟当前线程栈信息(value)存入linkedHashmap中
BlockCanaryInternals.getInstance().stackSampler.start();
}
if(null != BlockCanaryInternals.getInstance().cpuSampler) {
//同stackSampler，开启HandlerThread线程处理doSample()方法,主要是读
//取/proc/stat文件跟"/proc/" + this.mPid + "/stat"文件中的信息
BlockCanaryInternals.getInstance().cpuSampler.start();
}
}
private void stopDump() {
if(null != BlockCanaryInternals.getInstance().stackSampler) {
BlockCanaryInternals.getInstance().stackSampler.stop();
}
if(null != BlockCanaryInternals.getInstance().cpuSampler) {
BlockCanaryInternals.getInstance().cpuSampler.stop();
}
}
}
StackSampler类：
private static final LinkedHashMap<Long, String> sStackMap = new LinkedHashMap();
protected void doSample() {
StringBuilder stringBuilder = new StringBuilder();
//获取当前线程的调用栈，mCurrentThread这里代表主线程
StackTraceElement[] var2 = this.mCurrentThread.getStackTrace();
int var3 = var2.length;
for(int var4 = 0; var4 < var3; ++var4) {
StackTraceElement stackTraceElement = var2[var4];
stringBuilder.append(stackTraceElement.toString()).append("\r\n");
}
LinkedHashMap var8 = sStackMap;
synchronized(sStackMap) {
if(sStackMap.size() == this.mMaxEntryCount && this.mMaxEntryCount > 0) {
sStackMap.remove(sStackMap.keySet().iterator().next());
}
//sStackMap为LinkedHashMap，能记录我们先后插入顺序
sStackMap.put(Long.valueOf(System.currentTimeMillis()), stringBuilder.toString());
}
}
相关问题
一.ANR问题：Application Not Responding
在android中由Activity Manager和WindowManager来监控，当出现以下三种情况会报ANR
1.Service Timeout：服务在20s没执行
2.BroadcastQueue Timeout：前台广播在10s没执行
3.inputDispatching Timeout：输入事件在5s没执行(触屏，按键等)
主要原因：主线程在规定时间内没完成任务。具体分以下几类
1.主线程在做一些耗时工作
2.主线程被其他线程锁
3.cpu被其他进程占用
如何解决：
1.主线程读取数据，耗时的数据库读取
2.sharePreference的commit（同步），apply（异步）
3.不要在广播的onReceive中做耗时操作
4.Activity的生命周期不应该有太多耗时操作
watchdog-anr 如何检测ANR
使用：在Application中开启new ANRWatchDog().start();
原理：ANRWatchDog继承Thread
1.创建监测线程
2.该线程不断往UI线程post一个任务
3.睡眠固定时间
4.等该线程重新起来后检测之前post的任务是否执行了（任务执行的是++操作，判断只需要判断是否执行了++）
public class ANRWatchDog extends Thread {
private final Handler _uiHandler = new Handler(Looper.getMainLooper());
@Override
public void run() {
setName("|ANR-WatchDog|");
int lastTick;
int lastIgnored = -1;
while (!isInterrupted()) {
lastTick = _tick;
_uiHandler.post(_ticker);
try {
Thread.sleep(_timeoutInterval);
}
catch (InterruptedException e) {
_interruptionListener.onInterrupted(e);
return ;
}
// If the main thread has not handled _ticker, it is blocked. ANR.
if (_tick == lastTick) {
if (!_ignoreDebugger && Debug.isDebuggerConnected()) {
if (_tick != lastIgnored)
Log.w("ANRWatchdog", "An ANR was detected but ignored because the debugger is connected (you can prevent this with setIgnoreDebugger(true))");
lastIgnored = _tick;
continue ;
}
ANRError error;
if (_namePrefix != null)
error = ANRError.New(_namePrefix, _logThreadsWithoutStackTrace);
else
error = ANRError.NewMainOnly();
_anrListener.onAppNotResponding(error);
return;
}
}
}
}
二.线程，多线程问题
1.new Tread问题
调用start启动线程(就绪状态)，实现了多线程；run方法表示一个普通的方法,不代表多线程(??)
1).多个耗时任务就会开启多个新线程，开销非常大
2).如果在线程中执行循环任务，只能通过一个Flag来控制它的停止
3).没有线程切换的接口(只能通过handler或者其他的线程通信方式)
4).如果从UI线程启动，则该线程优先级默认为Default(和UI线程相同，可能还是会阻塞主线程)；Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
2.线程通信
多线程编程时有两大原则
1).不要阻塞UI线程
2).不要在UI线程之外访问UI组件
线程通信分两类
1).将任务从工作线程抛到主线程
2).将任务从主线程抛到工作线程
工作线程抛任务到主线程(不管是哪种方式，最终都是通过Handler)
1).通过Handler
2).activity.runOnUiThread(runnalbe);
3).AsynkTask
任务从主线程到工作线程
1).Thread/Runnable
2).HandlerThread
3).IntentService
