耗时整整3个月，我梳理了200道Android面试基础（下）【面试必考，全网最全，每天一遍】

本篇内容比较快捷短小。属于快问快答形式。大家可以下载下来，每天一遍。
记住，答案只是引导，在回答完后发散自己的引导思维。去引申。

上篇：耗时整整3个月，我梳理了200道Android面试基础（上）

create table table2 as select * from table1

102.SQLite

try{
	mSqliteDatabase.beginTransaction()
	…
	mSqliteDatabase.execSQL(….)
	…
	mSqliteDatabase.setTransactionSuccessful()
     }catch(Exception e)
     {
	e.printStackTrace()
     }finally{
	mSqliteDatabase.endTransaction()
     }

mSqliteDatabase.execSQL(“create table temp as select … from student”)
mSqliteDatabase.execSQL(“drop table if exists student”)
mSqliteDatabase.execSQL(“alter table temp rename to student”)

104.然后将带数据的SQLite同apk一起发布

  {
    InputStream is=getResources().openRawResource(R.raw.test)
    FileOutputStream fos=new FileOutputStream(databaseFiename)
    byte[] buffer= new byte[1024]
    int count=0
    while((count=is.read(buffer))!=-1)
    {
      fos.write(buffer,0,count)
    }
    fos.close()
    is.close()
  }
  SQLiteDatabase database=SQLiteDatabase.createOrOpenDatabase(databaseFilename,null)

105.Socket连接成功后，怎么获取服务器的ip和域名

socket.getInetAddress().getHostName()
socket.getInetAddress().getHostAddress()

  a)bis.mark(is.available());
    byte[] buffer=new byte[1024];
    String result="";
    int len;
    while ((len=bis.read(buffer))>0)
    {
   	result+=new String(buffer,0,len);
    }
    bis.reset();
    while ((len=bis.read(buffer))>0)
    {
 	result+=new String(buffer,0,len);
    }
    System.out.println(result);
    is.close();
    bis.close();

  Intent enableIntent=new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
  startActivityForResult(enableIntent,1)

  BluetoothAdapter bluetoothAdapter=BluetoothAdapter.getDefaultAdapter()
  bluetoothAdapter.enable()

111.如何获取已绑定的蓝牙设备

Set<BluetoothDevice> devices=bluetoothAdapter.getBoundedDeviecs()

112.搜索蓝牙的过程中经过哪些状态

IntentFilter filter=new IntentFilter(BluetoothDevice.ACTION_FOUND)
  this.registerReceiver(receiver,filter)
  filter=new IntentFilter(BluetoothDevice.ACTION_DISCOVERY_FINISHED)
  this.registerReceiver(receiver,filter)
  private final BroadcastReceiver receiver=new BroadcastReceiver()
  {
    @Override
    public void onReceive(Context context,Intent intent)
    {
	String action=intent.getAction()
 	if(BluetoothDevice.ACTION_FOUND.equals(action)
       {
	  BluetoothDevice device=intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
  	  if(device.getBondState()!=BluetoothDevice.BOND_BONDED)
	  {
            //TODO:处理这些未绑定的设备
 	  }
  	}else if(BluetoothDevice.ACTION_DISCOVERY_FINISHED.equals(action)
	{

	}
    }
  } 
  
  adapter.startDiscovery() 

113.隐式Intent
系统默认 Intent
a).Intent.ACTION_DIAL 拨打电话,需要添加权限android.permission.CALL_PHONE
b).Intent.ACTION_NEW_OUTGOING_CALL 用户主动发起拨打电话
c).Intent.ACTION_SCREEN_ON|Intent.ACTION_SCREEN_OFF

114.如何采用广播监听去电和来电

public class MyReceiver extends BroadcastReceiver
  {
    @Override
    public void onReceive(final Context context,Intent intent)
    {
	if(intent.getAction().equals(Intent.ACTION_NEW_OUTGOING_CALL)
	{
		//todo:去电
	}else{
		//todo:来电
	}
    } 
  }

xml描述

  <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS"/>
  <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  <receiver android:name=".PhoneBroadcastReceiver">
	<intent-filter android:priority="1000">
	  <action android:name="android.intent.action.NEW_OUTGOING_CALL"/>
	  <action android:name="android.intent.action.PHONE_STATE"/> 
        </intent-filter>
  </receiver>

TelephonyManager tm =(TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE)
  switch(tm.getCallState())
  {
    case TelephonyManager.CALL_STATE_RINGING:
 
      break;
    case TelephonyManager.CALL_STATE_IDLE:

      break;
  }

TelephonyManager telephonyManager=(TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
       Class<TelephonyManager> telephonyManagerClass=TelephonyManager.class;
       Method telephonyMethod=telephonyManagerClass.getDeclaredMethod("getITelephony",null);
       telephonyMethod.setAccessible(true);
       Object obj=telephonyMethod.invoke(telephonyManager,null);
       Method endCallMethod=obj.getClass().getDeclaredMethod("endCall");
       endCallMethod.setAccessible(true);
       //执行电话挂断
       endCallMethod.invoke(obj,null);

       Method answerRinginCallMethod=obj.getClass().getDeclaredMethod("answerRinginCallMethod",null);
       answerRinginCallMethod.setAccessible(true);
       answerRinginCallMethod.invoke(obj,null);

117.请给出访问通话记录的Content Provider URI

>><uses-permission android:name=“READ_CALL_LOG”/>
>>Uri.parse(“content://call_log/calls”)
>>M版本以上进行动态权限申请
  a).if(PackageManager.PERMISSION_GRANTED==checkSelfPermission(Manifest.permission.READ_CALL_LOG)) {
       Cursor cursor = getContentResolver().query(Uri.parse("content://call_log/calls"), null, null, null, null, null);
       cursor.moveToFirst();
       while (!cursor.isAfterLast()) {
         int phone = cursor.getInt(cursor.getColumnIndex(CallLog.Calls.NUMBER));
 	 String name=cursor.getString(cursor.getColumnIndex(CallLog.Calls.CACHED_NAME));
        Log.v(“call_log”,phone+””);
         cursor.moveToNext();
       }
     }else{
        requestPermissions(new String[]{Manifest.permission.READ_CALL_LOG},1);
     }
     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
	 super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode)
        {
	   case 1:
	     if(grantResuls[0]==PackageManager.PERMISSION_GRANTED)
		…
	     break;
        }
     }

119.发送短信 //需要动态请求权限:android.permission.SEND_SMS

SmsManager smsManager=SmsManager.getDefault()
  String message=“i gonna fuck u”
  List<String> msges=smsManager.divideMessage(message);
  for(int i=0;i<msges.size();i++)
  {
      smsManager.sendTextMessage(“12345678”,null,”你好吗”,PendingIntent pi,PendingIntent di)	
  }

Contacts&CommonDataKinds.Phone //存储通讯录中每个人的概要信息
a).查询姓名

    Cursor c=getContentResolver().query(ContactsContract.Contacts.CONTENT_URI,null,null,…)
    String name=c.getString(c.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME_PRIMARY))

b).查询电话

Cursor c=getContentResolver().query(ContactsContract.Contacts.CONTENT_URI,null,…)
int id=c.getInt(c.getColumnIndex(ContactsContract.Contacts._ID))
c.close()
c=getContentResolver().query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI,null,
ContactsContract.CommonDataKinds.Phone.CONTACT_ID+”=?”,id,null)
c.moveToFirst()
while(!c.isAfterLast())
{
  String 														phone=c.getString(c.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NORMALIZED_NUMBER))
  …
}
c.close()

Uri uri =Uri.parse(path)
  videoView.setVideoURI(uri)
  videoView.start()
  
  videoView.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
            @Override
            public void onPrepared(MediaPlayer mp) {

                mp.start();// 播放
                Toast.makeText(MainActivity.this, "开始播放！", Toast.LENGTH_LONG).show();
            }
        });

  videoView.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
            @Override
            public void onCompletion(MediaPlayer mp) {
                Toast.makeText(MainActivity.this, "播放完毕", Toast.LENGTH_SHORT).show();
            }
        });

InputStream is=getResources().openRawResource(R.raw.xxx)  //只适合读取raw下的资源
  BitmapFactory.Options options=new BitmapFactory.Options()
  options.inSampleSize=2
  Bitmap bitmap=BitmapFactory.decodeStream(is,null,opts)
  canvas.drawBitmap(bitmap,10,10,null)
Bitmap bitmap=BitmapFactory.decodeResource(getResources(),R.drawable.tree)

123.调用Drawable进行绘图

Drawable.draw(canvas)	//调用setBounds设置范围,在调用draw
  Drawable drawable=getResources().getDrawable(R.drawable.tree)
  drawable.setBounds(x,x,x,x)
  drawable.draw(canvas)

124.如何设置图像透明度

Paint paint=new Paint()
  paint.setAlpha(0.5)
  canvas.drawBitmap(bitmap,sourceRect,destRect,paint)

125.如何旋转View

Matrix
  Matrix matrix=new Matrix()
  matrix.setRotate(120,80,80)
  canvas.setMatrix(matrix)

126.Activity 切换

overridePendingTransition(int enterAnim,int exitAnim)
  a).Intent intent=new Intent(this,xxx.class)		  //跳转
     startActivity(intent);
     overridePendingTransition(R.anim.enter,R.anim.exit)
  b).public void finish()
     {
	overridePendingTransition(R.anim.enter,R.anim.exit)	//退场
     }

127.Android

  //lottey_animlist.xml
  <?xml version="1.0" encoding="utf-8"?>
  <animation-list xmlns:android="http://schemas.android.com/apk/res/android"
      android:oneshot="false"><!— oneshot 代表只会播放一次,默认为循环播放->
      <item
        android:drawable="@mipmap/lottery_1"
        android:duration="200" />
      <item
        android:drawable="@mipmap/lottery_2"
        android:duration="200" />
      <item
        android:drawable="@mipmap/lottery_3"
        android:duration="200" />
      <item
        android:drawable="@mipmap/lottery_4"
        android:duration="200" />
      <item
        android:drawable="@mipmap/lottery_5"
        android:duration="200" />
      <item
        android:drawable="@mipmap/lottery_6"
        android:duration="200" />
  </animation-list>
  //使用ImageView作为载体显示
  imageView.setImageResource(R.drawable.lottery_animlist)
  AnimationDrawable animationDrawable=(AnimationDrawable)button.getBackground()
  animationDrawable.start()

onAnimationEnd 接口 采用hashCode()进行区分

128.动画

AlphaAnimation 透明度渐变，针对
a)动画声明 =>

<alpha xmlns:android="http://schemas.android.com/apk/res/android"  
android:interpolator="@android:anim/accelerate_decelerate_interpolator"  
android:fromAlpha="1.0"  
android:toAlpha="0.1"  
android:duration="2000"/>  

b)动画调用 =>

Animation animation= AnimationUtils.loadAnimation(this,R.anim.alpha_demo)
imageView.startAnimation(animation)

RotateAnimation 旋转渐,针对
a)动画声明 =>

<rotate xmlns:android="http://schemas.android.com/apk/res/android"  
android:interpolator="@android:anim/accelerate_decelerate_interpolator"  
android:fromDegrees="0"  
android:toDegrees="360"  
android:duration="1000"  
android:repeatCount="1"  
android:repeatMode="reverse"/>

ScaleAnimation 放缩渐变,需要指定参考点,针对
a)动画声明 =>

  <scale xmlns:android="http://schemas.android.com/apk/res/android"  
    android:interpolator="@android:anim/accelerate_interpolator"  
    android:fromXScale="0.2"  
    android:toXScale="1.5"  
    android:fromYScale="0.2"  
    android:toYScale="1.5"  
    android:pivotX="50%"  
    android:pivotY="50%"  
    android:duration="2000"/>  

TranslateAnimation 位移渐变,需要指定开始和结束坐标,针对
a)动画声明 =>

<translate xmlns:android="http://schemas.android.com/apk/res/android"  
android:interpolator="@android:anim/accelerate_decelerate_interpolator"  
android:fromXDelta="0"  
android:toXDelta="320"  
android:fromYDelta="0"  
android:toYDelta="0"  
android:duration="2000"/>

LayoutAnimation //在ViewGroup中指定，并作用于它的各个子元素

a)动画声明 => //res/anim/anim_layout.xml

<layoutAnimation
   xmlns:android=“http://schemas.android.com/apk/res/android”
   android:delay=“0.5”
   android:animationOrder=“normal”
   android:animation=“@anim/anim_item”/>

b)为子元素指定具体动画

<set xmlns:android=“http://schemas.android.com/apk/res/android”
     android:duration=“3000”  >
<alpha android:fromAlpha=“0.0 android:toAlpha=“1.0”/>
<translate android:fromXDelta=500” android:toXDelta=“0”/>
</set>

c)设置父容器属性

<ListView android:layoutAnimation=“@anim/anim_layout”/>

AnimationSet 动画集合,针对
a)动画声明 =>

<set xmlns:android="http://schemas.android.com/apk/res/android"  
  android:interpolator="@android:anim/decelerate_interpolator"  
  android:shareInterpolator="true" >  
  
  <scale  
    android:duration="2000"  
    android:fromXScale="0.2"  
    android:fromYScale="0.2"  
    android:pivotX="50%"  
    android:pivotY="50%"  
    android:toXScale="1.5"  
    android:toYScale="1.5" />  
  
  <rotate  
    android:duration="1000"  
    android:fromDegrees="0"  
    android:repeatCount="1"  
    android:repeatMode="reverse"  
    android:toDegrees="360" />  
  
  <translate  
    android:duration="2000"  
    android:fromXDelta="0"  
    android:fromYDelta="0"  
    android:toXDelta="320"  
    android:toYDelta="0" />  
  
  <alpha  
    android:duration="2000"  
    android:fromAlpha="1.0"  
    android:toAlpha="0.1" />  
  
 </set>  

129.属性动画 Animator

  a)ObjectAnimator
    .ofFloat(view,”rotateX”,0f,360f)
    .setDuration(500)
    .start();
  b)ObjectAnimator
    .ofFloat(view,”y”,sunYStart,sunYEnd)
    .setDuration(3000)
    .setRepeatCount(Animation.INFINITE)
    .setRepeatMode(Animation.REVERSE)
    .setInterpolator(new AccelerateInterpolator());	//设置插值模式为加速
    oa.start();
  c)TypeEvaluator	//辅助ObjectAnimator精确第计算由初始值到结束值的插值模式
    ObjectAnimator
    .ofInt(mSkyView,”backgroundColor”,mBlueSkyColor,mRedSkyColor)
    .setDuration(3000)
    .setEvaluator(new ArgbEvaluator())		//针对色彩的evaluator
    .start();
  d)添加插值监听
    oa.start();
    oa.addUpdateListener(new AnimatorUpdateListener()
    {
	@Override
	public void onAnimationUpdate(ValueAnimator animator)
	{
	  float cVal = (Float) animator.getAnimatedValue();  
          view.setAlpha(cVal);  
          view.setScaleX(cVal);  
          view.setScaleY(cVal);  
	}
    }

  a)添加插值监听
   	ValueAnimator animator=ValueAnimator.ofFloat(0,mScreenHeight-mBlueBall.getHeight()); 
	animator.setDuraton(3000).start();
	animator.addUpdateListener(new AnimatorUpdateListener(){
	  @Override
	  public void onAnimationUpdate(ValueAnimator animation)
	  {
	    mBlueBall.setTranslationY((Float)animation.getAnimatedValue())
	  }
	});
	va.setDuration(3000)
  b)返回自定义类型的估值
 	ValueAnimator animator=new ValueAnimator();
	animator.setDuration(3000);
	animator.setObjectValues(new PointF(0,0));
	animator.setEvaluator(new TypeEvaluator<PointF>(){
	    
	    // fraction = t / duration  
            @Override  
            public PointF evaluate(float fraction, PointF startValue,  
                    PointF endValue)  
            {  
                Log.e(TAG, fraction * 3 + "");  
                // x方向200px/s ，则y方向0.5 * 10 * t  
                PointF point = new PointF();  
                point.x = 200 * fraction * 3;  
                point.y = 0.5f * 200 * (fraction * 3) * (fraction * 3);  
                return point;  
            }  

	});

	ObjectAnimator anim1 = ObjectAnimator.ofFloat(mBlueBall, "scaleX",1.0f, 2f);  
	ObjectAnimator anim2 = ObjectAnimator.ofFloat(mBlueBall, "scaleY", 1.0f, 2f);  	 
	AnimatorSet animSet=new AnimatorSet();
	animSet.setDuration(2000)
	animSet.setInterpolator(new LinearInterpolator());
	animist.playTogether(anim1,anim2);
	animist.start();
  a)AnimatorSet 设置动画执行秩序  
 	animSet.play(anim1).with(anim2)
	animSet.play(anim2).before(anim3)
  b)AnimatorSet xml设置
    Animator animator=AnimatorInflater.loadAnimator(this,R.animator.property_t);
    animator.setTarget()
    animator.start()

  <resources>
    <string-array name=‘planet_array’>
	<item>venus</item>
	<item>mars</item>
	<item>earth</item>
    </string-array>
  </resources>

  String[] names=getResources().getStringArray(R.array.names)

  <?xml version=“1.0” encoding=“utf-8”?>
  <layer-list xmlns:android=“http://schemas.android.com/apk/res/android”>
    <item>
      <bitmap android:src=“” android:gravity=“center”/>
    </item>
    <item android:top=“20dp” android:left=“20dp”>
      <bitmap android:src=“” android:gravity=“center”/>
    </item>
  </layer-list>

  <clip xmlns=“http://schemeas.android.com/apk/res/android”
	android:drawable=“”
	android:orientation=“horizontal”
	android:gravity=“left”
  />

  ClipDrawable drawable=(ClipDrawable)imageView.getBackground()
  drawable.setLevel(3000)//内部预设最大值为10000

  <shape xmlns=“http://schemas.android.com/apk/res/android” android:shape=“rectangle”>
    <!— 定义渐变色 —>
    <gradient android:startColor=“#00f” android:endColor=“#f00” android:angle=“45”/>
    <padding  android:left=“7dp” android:right=“7dp”/>
    <corners android:radius=“8dp”/>
    <size android:height="20dp" android:width="20dp"/>
    <solid android:color=“”/>
    <stroke android:color=“” android:width=“”/>
  </shape>

  <resources>
    <style name=“customText” parent=“@style/Text”>
	<item name=“android:textSize”>20sp</item>
	<item name=“android:textColor”>#008</item>
    </style>
  </resources>

布局文件中的”@“、”+”、”?”含义
引用资源
+号代表所引用的资源id在R类不存在
?代表引用当前主题的属性

android获取屏幕高度和宽度的办法
:1.通过获取DisplayMetrics

DisplayMetrics dm=getResources().getDisplayMetrics()
 int width=dm.widthPixels
 int height=dm.heightPixels

:2.通过windowManager

  >DisplayMetrics dm=new DisplayMetrics()
   getWindowManager().getDefaultDisplay(dm)
   dm.widthPixels , dm.heightPixels

138.AsyncTask
在ui主线程 执行.execute(T… params, T …progress,T result) 对应的参数会再doInBackground接收到回调 => onPreExecute、onPostExecute、doInBackground、onProgressUpdate
AsyncTask的模板参数

示例:
:1.ProgressBarAsyncTask asyncTask = new ProgressBarAsyncTask(textView, progressBar);
asyncTask.execute(1000);
//AsyncTask子类
public class ProgressBarAsyncTask extends AsyncTask{

    private TextView textView;  
    private ProgressBar progressBar; 

    public ProgressBarAsyncTask(TextView textView, ProgressBar progressBar) {  
        super();  
        this.textView = textView;  
        this.progressBar = progressBar;  
    }  
    
    @Override  
    protected String doInBackground(Integer... params) {  
        NetOperator netOperator = new NetOperator();  
        int i = 0;  
        for (i = 10; i <= 100; i+=10) {  
            netOperator.operator();  
            publishProgress(i);  			//进入onProgressUpdate回调
        }  
        return i + params[0].intValue() + "";  
    }  
    
    //该回调处于ui主线程
    @Override  
    protected void onProgressUpdate(Integer... values) {  
        int vlaue = values[0];  
        progressBar.setProgress(vlaue);  
    }

    //该方法运行在UI线程当中
    @Override  
    protected void onPreExecute() {  
        textView.setText("开始执行异步线程");  
    }  

    //该回调处于ui主线程,onPostExecute的形参类型由result决定
    @Override  
    protected void onPostExecute(String result) {  
        textView.setText("异步 *** 作执行结束" + result);  
    }    
  }

139.Intent可传递的数据类型

8种基本数据类型:double、int、float、char、long、byte、short、String
实现了Parcelable接口的类
实现了Serializable接口的类

141.AlarmManager //闹钟

  HandlerThread mThread=new HandlerThread(“xx”);
  mThread.start();
  handler = new Handler( myHandlerThread.getLooper() ){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //这个方法是运行在 handler-thread 线程中的 ，可以执行耗时 *** 作
                Log.d( "handler " , "消息： " + msg.what + "  线程： “+
   				Thread.currentThread().getName()  ) ;
            }
   };
  handler.send(xxx)

Thread

  a)没有Looper 所以需要在Thread的run中去执行Looper.prepare()和Looper.loop()
  b)Hanlder的初始化需要当前线程具有looper，所以也得放置在Looper的循环中

HandlerThread
a)HandlerThread自行进行Looper的prepare、loop等api
b)允许调用getLooper()获取Looper实例
c)可以在handleMessage执行耗时
d)HandlerThread自己创建Looper，分担了主Looper的压力
e)异步请求是排队调用的，不适合网络IO

public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs)		//返回支持设置的属性
  {
    return new MarginLayoutParams(getContext(),attrs);
  }
  
onMeasure => a)子View的宽高测量调用  b)setMeasuredDimension设置宽高
//例子
  @Override 
  protected void onMeasure(int widthMeasureSpec,int heightMeasureSpec)
  {
    int widthMode=MeasureSpec.getMode(widthMeasureSpec);
    int heightMode=MeasureSpec.getMode(heightMeasureSpec);
    int sizeWidth=MeasureSpec.getSize(widthMeasureSpec);
    int sizeHeight=MeasureSpec.getSize(heightMeasureSpec);
    //进行childView的宽高计算，会进入view的onMeasure回调
    measureChildren(widthMeasureSpec, heightMeasureSpec)	
		//for+measureChild(child,widthMeasureSpec,heightMeasureSpec)
    int cCount = getChildCount();  
    int cWidth = 0;  
    int cHeight = 0;  
    MarginLayoutParams cParams = null;  
    for (int i = 0; i < cCount; i++)  
    {
      View childView = getChildAt(i);  
      cWidth = childView.getMeasuredWidth();  
      cHeight = childView.getMeasuredHeight();
      cParams = (MarginLayoutParams) childView.getLayoutParams();
      // 上面两个childView  
      if (i == 0 || i == 1)  
      {  
        tWidth += cWidth + cParams.leftMargin + cParams.rightMargin;  
      } 
      if (i == 2 || i == 3)  
      {  
         bWidth += cWidth + cParams.leftMargin + cParams.rightMargin;  
      }  
      width=Math.max(tWidth,bWidth) 
      
    }
    setMeasuredDimension((widthMode == MeasureSpec.EXACTLY) ? sizeWidth  
                : width, (heightMode == MeasureSpec.EXACTLY) ? sizeHeight  
                : height);  
  }
onLayout => 作为虚函数需要由子类实现  a)放置各个子View
  protected void onLayout(boolean changed,int l,int t,int r,int b)
  {
    int cCount = getChildCount(); 
    MarginLayoutParams cParams = null;
    for(int i=0;i<cCount;i++)
    {
      View childView = getChildAt(i);
      int cWidth=childView.getMeasuredWidth()
      int cHeight=childView.getMeasuredHeight()
      //……
      childView.layout(cl, ct, cr, cb);  
    }
  }

147.JVM的GC算法

> String url = "http://wwww.baidu.com"		//同步
  OkHttpClient okHttpClient = new OkHttpClient()
  final Request request = new Request.Builder()
    .url(url)
    .get()
    .build();
  Response response= okHttpClient.newCall(request).execute()
  String result= response.body().toString
> String url = "http://wwww.baidu.com"		//异步
  OkHttpClient okHttpClient = new OkHttpClient()
  final Request request = new Request.Builder()
    .url(url)
    .get()
    .build()
  okHttpClient.newCall(request).enqueue(ne Callback(){
@Override
	  public void onFailure(Call call, IOException e) {
        Log.d(TAG, "onFailure: ");
      }
 	@Override
      public void onResponse(Call call, Response response) throws IOException {
        Log.d(TAG, "onResponse: " + response.body().string());
    }
  })

:2.post方式 //new OkHttpClient -> 构造RequestBody、指定mimeType -> 构造request

   > OkHttpClient okHttpClient= new OkHttpClient()
     RequestBody requestBody=new FormBody.Builder()
				.add("username","danding")
				.build()
     Request request= new RequestBody.Builder()
			.url(url)
			.post(requestBody)
			.build()
     okHttpClient.newCall(request).enqueue(new CallBack(){
	@Override
    	  public void onFailure(Call call, IOException e) {
            Log.d(TAG, "onFailure: ");
          }
     	@Override
          public void onResponse(Call call, Response response) throws IOException {
            Log.d(TAG, "onResponse: " + response.body().string());
        }
     })

:3.自定义Interceptor

> @Override
  public Response intercept(Chain chain) throws IOException {
 Request request=chain.request()
 //todo.... 
 Response response=chain.proceed(request)
 return response
  }

源码
:1.创建OkHttpClient

> public OkHttpClient() {		//直接创建的 OkHttpClient对象并且默认构造builder对象进行初始化
   this(new Builder());
  }
  OkHttpClient(Builder builder) {
this.interceptors = Util.immutableList(builder.interceptors)
...
  }

:2.创建Request //代码new Request.Builder().url(url).build()

> public final class Request {
public Builder() {
  	  this.method = "GET";
   	  this.headers = new Headers.Builder();
    }
public Builder url(String url) {
  HttpUrl parsed = HttpUrl.parse(url);	//获取scheme、host、port等信息
  return url(parsed)		//设置this.url成员
}
  }

:3.okHttpClient.newCall(request)

> public class OkHttpClient implements Cloneable, Call.Factory, WebSocket.Factory {
    @Override 
    public Call newCall(Request request) {
     return new RealCall(this, request, false /* for web socket */);
    }
    ...
  }
> final class RealCall implements Call {
 @Override 
     public void enqueue(Callback responseCallback) {
     synchronized (this) {
   if (executed) throw new IllegalStateException("Already Executed");
          executed = true;
       }
       captureCallStackTrace();
       client.dispatcher().enqueue(new AsyncCall(responseCallback))
     }
  }
> class AsyncCall extends NamedRunnable{	//implements Runnable 
protected void execute() {
  try {
        Response response = getResponseWithInterceptorChain()//!!!核心
    ... List<Interceptor> interceptors = new ArrayList<>()
	interceptors.addAll(client.interceptors())
	interceptors.add(retryAndFollowUpInterceptor)
	interceptors.add(new BridgeInterceptor(client.cookieJar()))
	interceptors.add(new ConnectInterceptor(client))
	interceptors.add(new CallServerInterceptor(forWebSocket))
   
    ... Interceptor.Chain chain = new RealInterceptorChain(
    		interceptors, null, null, null, 0, originalRequest);
	return chain.proceed(originalRequest)

    ... public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec 			httpCodec ,RealConnection connection) throws IOException {
	  if (index >= interceptors.size()) throw new AssertionError()
	  val interceptor=interceptos.get(index)
	  Response response = interceptor.intercept(next)
	
	}
    responseCallback.onResponse(RealCall.this, response)
}
  }

:4.Dispatcher线程池

 > 	/** 最大并发请求数为64 */
private int maxRequests = 64;
/** 每个主机最大请求数为5 */
private int maxRequestsPerHost = 5;

/** 线程池 */
private ExecutorService executorService;

/** 准备执行的请求 */
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();

/** 正在执行的异步请求，包含已经取消但未执行完的请求 */
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();

/** 正在执行的同步请求，包含已经取消单未执行完的请求 */
private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();

> enqueue //压入请求
  synchronized void enqueue(AsyncCall call) {
   //maxRequest==64	
   if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
  	 runningAsyncCalls.add(call);		//压入正在执行队列
     executorService().execute(call);
   } else {
     readyAsyncCalls.add(call);		//压入就绪队列
   }
  }

:5.Interceptor

>BridgeInterceptor -> 添加Content-Type、Content-Length、User-Agent等协议头
>ConnectInterceptor -> ....
>CallServerInterceptor -> 实际发送网络请求

149.ButterKnife //源码阅读
初始化
:1.定义处理器

```java
  public class MyProcessor extends AbstractProcessor {

    //用来指定你使用的 java 版本。通常你应该返回
    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    //会被处理器调用，可以在这里获取Filer，Elements，Messager等辅助类，后面会解释
    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
    }

  //这个方法返回stirng类型的set集合，集合里包含了你需要处理的注解
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> annotataions = new LinkedHashSet<String>();
        annotataions.add("com.example.MyAnnotation");
        return annotataions;
    }


   //核心方法，这个一般的流程就是先扫描查找注解，再生成 java 文件
   //这2个步骤设计的知识点细节很多。
    @Override
    public boolean process(Set<? extends TypeElement> annoations,
            RoundEnvironment env) {
        return false;
    }
}

:2.注册处理器

     @AutoService(Processor.class)
     Public class xxx extends AbstractProcessor{

     }
>>流程 
  :1.process (annotations:Set , env:RoundEnvironment)
   ->Map<TypeElement, BindingSet> targetClassMap = findAndParseTargets(env)
     ...Map<TypeElement,BindingSet> targetClassMap
	//查找用BindView注解的元素
     ...for(Element element:env.getElementsAnnotatedWith(BindView.class)
	try{
   	  parseBindView(element, Map<TypeElement,BindingSet.Builder>builderMap,...) 
	       ....enclosingElement=(TypeElement)element.getEnclosingElement()
   		    TypeMirror elementType = element.asType()//转换成TypeMirror才能获取类型等信息
		    if (elementType.getKind() == TypeKind.TYPEVAR) {//变量类型
			TypeVariable typeVariable = (TypeVariable) elementType
		        elementType = typeVariable.getUpperBound()//获取上限类型
		    }
		    //检查1!!!
		    if (!isSubtypeOfType(elementType, VIEW_TYPE) && !isInterface(elementType)) {
			throw Error
		    }
		    int id = element.getAnnotation(BindView.class).value()//获取资源id
		    BindingSet.Builder builder = builderMap.get(enclosingElement)
		    if(builder!=null){}
		    else
		      builder = getOrCreateBindingBuilder(builderMap, enclosingElement)
			... builder=BindingSet.newBuilder(enclosingElement)
			     ->packageName= getPackage(enclosingElement).getQualifiedName()
				 className=enclosingElement.getQualifiedName().toString()
				 bindingClassName = ClassName.get(packageName, className + "_ViewBinding")
			... builderMap.put(enclosingElement,builder)
		      
		    String name = simpleName.toString();//绑定注解的变量名
		    TypeName type = TypeName.get(elementType)//变量类型
		    //往刚刚生成的BuildingSet.Builder加入field信息
		    builder.addField(resourceId, new FieldViewBinding(name, type, required))
		       ... new FieldViewBinding(name, type, required)//分配变量名、变量类型

		       ... viewId=new ViewBinding.Builder(id)
			   viewIdMap.put(id,viewId)//viewIdMap为BindingSet的私有变量
		     	   viewId.setFieldBinding(biding)
			  

	  }
	   
  :2.for (Map.Entry<TypeElement, BindingSet> entry : bindingMap.entrySet()) {
       TypeElement typeElement = entry.getKey();
       BindingSet binding = entry.getValue();
       binding.brewJava 
	 ... BuildingSet.createType	//创建TypeSpec
             TypeSpec.Builder result = TypeSpec.classBuilder(bindingClassName.simpleName())
        	.addModifiers(PUBLIC);     //创建类
	      //设置类要实现的接口
	      if (parentBinding != null) {
      		 result.superclass(parentBinding.bindingClassName);
    	      } else {
      		 result.addSuperinterface(UNBINDER);//设置实现Unbinder
    	      }
	      if (hasTargetField()) {	   //检查FieldViewBinding
     		 result.addField(targetTypeName, "target", PRIVATE);
              }
	      //创建构造函数
	      if (isActivity) 
      		result.addMethod(createBindingConstructorForActivity(useAndroidX));
   		  .... MethodSpec.Builder builder = MethodSpec.constructorBuilder()
        		.addAnnotation(useAndroidX ? UI_THREAD_ANDROIDX : UI_THREAD)
 		        .addModifiers(PUBLIC)
		        .addParameter(targetTypeName, "target");//targetTypeName指向Activity
	      //构建bind
	      result.addMethod(createBindingConstructor(sdk, debuggable, useAndroidX))
		... if (hasViewBindings()) {
			for (ViewBinding binding : viewBindings) {
        	           addViewBinding(constructor, binding, debuggable)
			    -> FieldViewBinding fieldBinding = binding.getFieldBinding()
				
      			}
		    }
	      //针对hasViewBinding,构建unbind函数
	      if (hasViewBindings() || parentBinding == null) {
	        result.addMethod(createBindingUnbindMethod(result, useAndroidX));
              }
	
	      
     }

概念

  :1.parseBindView(Element element,....)
     TypeMirror elementType = element.asType()
     if (elementType.getKind() == TypeKind.TYPEVAR) //注解在变量
     {
       TypeVariable typeVariable = (TypeVariable) elementType;
       elementType = typeVariable.getUpperBound();//获取变量的上界,比如TextView extends View 
     }
     //判断是否为View的子类型,不是的话报错
     if (!isSubtypeOfType(elementType, VIEW_TYPE) && !isInterface(elementType)) {
      if (elementType.getKind() == TypeKind.ERROR) {
        note(element, "@%s field with unresolved type (%s) "
                + "must elsewhere be generated as a View or interface. (%s.%s)",
            BindView.class.getSimpleName(), elementType, enclosingElement.getQualifiedName(),
            element.getSimpleName());
      } else {
        error(element, "@%s fields must extend from View or be an interface. (%s.%s)",
            BindView.class.getSimpleName(), enclosingElement.getQualifiedName(),
            element.getSimpleName());
        hasError = true;
      }
    }
    //获取@BindView的id值
    int id = element.getAnnotation(BindView.class).value();
    //检查是否有缓存,有则生成ViewBindings
    BindingClass bindingClass = targetClassMap.get(enclosingElement);
    if (bindingClass != null) {
      ViewBindings viewBindings = bindingClass.getViewBinding(getId(id));
      if (viewBindings != null && viewBindings.getFieldBinding() != null) {
        FieldViewBinding existingBinding = viewBindings.getFieldBinding();
        error(element, "Attempt to use @%s for an already bound ID %d on '%s'. (%s.%s)",
            BindView.class.getSimpleName(), id, existingBinding.getName(),
            enclosingElement.getQualifiedName(), element.getSimpleName());
        return;
      }
    } else {
      //声称_ViewBinding类
      bindingClass = getOrCreateTargetClass(targetClassMap, enclosingElement);
    }
    //name就是word
    String name = element.getSimpleName().toString();
    //类型的名字
    TypeName type = TypeName.get(elementType);
    //生成FieldViewBinding实体
    FieldViewBinding binding = new FieldViewBinding(name, type, required)
    //5.加入到 bindingClass 成员变量的集合中
    bindingClass.addField(getId(id), binding);

:2.getOrCreateTargetClass			//获取或者创建BindingClass

 >BindingClass bindingClass = targetClassMap.get(enclosingElement);
  //再次判断
  if (bindingClass == null) {
     TypeName targetType = TypeName.get(enclosingElement.asType())
 String packageName = getPackageName(enclosingElement);//获取该类的包名
 //类名字
     String className = getClassName(enclosingElement, packageName)
     ClassName bindingClassName = ClassName.get(packageName, className + "_ViewBinding")
     boolean isFinal = enclosingElement.getModifiers().contains(Modifier.FINAL)
     bindingClass = new BindingClass(targetType, bindingClassName, isFinal)
 //加入集合，缓存
     targetClassMap.put(enclosingElement, bindingClass);
  }

:3.process //生成java文件

 >//遍历生存生成java 文件
  for (Map.Entry<TypeElement, BindingClass> entry : targetClassMap.entrySet()) {
    TypeElement typeElement = entry.getKey();
    BindingClass bindingClass = entry.getValue();

    JavaFile javaFile = bindingClass.brewJava();
    try {
      javaFile.writeTo(filer);
    } catch (IOException e) {
    }
  }

:4.brewJava //生成

BindingClass的数据结构
:1.

注解

  @Target({ElementType.FIELD})
  @Retention(RetentionPolicy.CLASS)
  public @interface BindView{
    @IdRes int value();
  }

 >public final class HelloWorld{
public static void main(String[] args){
  System.out.println(“hello,JavaPoet!”);
}
  }

b).? extends AbstractProcessor

 {
private Filer filer;

@Override  
   public synchronized void init(ProcessingEnvironment processingEnv) {  
     super.init(processingEnv);  
     // Filer是个接口，支持通过注解处理器创建新文件  
     filer = processingEnv.getFiler();  
   }  	

public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { 
   for (TypeElement element : annotations) {  
         if (element.getQualifiedName().toString().equals(JPHelloWorld.class.getCanonicalName())) {  
            // 创建main方法  
            MethodSpec main = MethodSpec.methodBuilder("main")  
                    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)  
                    .returns(void.class)  
                    .addParameter(String[].class, "args")  
                    .addStatement("$T.out.println($S)", System.class, "Hello, JavaPoet!")  
                    .build();  
            // 创建HelloWorld类  
            TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")  
                    .addModifiers(Modifier.PUBLIC, Modifier.FINAL)  
                    .addMethod(main)  
                    .build();  
  
            try {  
                // 生成 com.example.HelloWorld.java  
                JavaFile javaFile = JavaFile.builder("com.example", helloWorld)  
                        .addFileComment(" This codes are generated automatically. Do not modify!")  
                        .build();  
                //　生成文件  
                javaFile.writeTo(filer);  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
         }  
      }  
      return true;  
}	
 }

  :1.CodeBlock.Builder builder=CodeBlock.builder()
	.add("target.$L",fieldBinding.getName())
  :2.赋值
     if (requiresCast) {	//需要转型
        builder.add("($T) ", fieldBinding.getType());
      }
     builder.add("source.findViewById($L)", binding.getId().code);  //getId对应设置时的数字
- bind 				//运行时
  :1.public static Unbinder bind(Activity target){		//针对Activity和DecorView
	View sourceView=target.getWindow().getDecorView()
	return createBinding(target,sourceView)
     }
  :2.public static Unbinder crateBinding(Object target,View source)
     {
	Class<?> targetClass =target.getClass()
       if (debug) Log.d(TAG, "Looking up binding for " + targetClass.getName());
       Constructor<? extends Unbinder> constructor = findBindingConstructorForClass(targetClass)
	//返回构造器，以便初始化对象
       if (constructor == null) {
         return Unbinder.EMPTY;
       }
       try {
         return constructor.newInstance(target, source);		//初始化对象
       } catch (IllegalAccessException e) {
         ….
       }
    }
  :3.Constructor<? extends Unbinder> findBindingConstructorForClass(Class<?> cls){
	Constructor<? extends Unbinder> bindingCtor = BINDINGS.get(cls)//查看缓存
  	if (bindingCtor != null) {
           if (debug) Log.d(TAG, "HIT: Cached in binding map.");
           return bindingCtor;
        }
	String clsName = cls.getName()		//cls属于Class，调用getName获取类名
	
	try {
          Class<?> bindingClass = cls.getClassLoader().loadClass(clsName +"_ViewBinding”)
          bindingCtor = (Constructor<? extends Unbinder>) bindingClass.getConstructor(cls, View.class);
         } catch (ClassNotFoundException e) {
            bindingCtor = findBindingConstructorForClass(cls.getSuperclass());
         } catch (NoSuchMethodException e) {
         }
         BINDINGS.put(cls, bindingCtor)	
     }

150.Dalvik内存模型

Live Bitmap用于标记上一次GC时被引用的对象,也就是未回收对象
Mark Bitmap标记当前GC有被引用的对象
回收Live Bitmap=1, Mark Bitmap=0的对象

标记根对象(非并行) -> 标记栈变量、静态成员、方法区常量、本地方法被引用的对象
标记被根集所引用的对象(允许并行) -> 增加Card Table,以免其他线程更改了该对象的引用情况

在之后的过程中，d出Mark Stack的对象，并标记在Bitamap之中，并将该对象的引用也压入Mark Stack

151.ART垃圾回收

151.2.JVM 可达性分析中哪些对象可以作为根节点

val subscriberClass=subscriber.getClass()
  
List<SubscriberMethod> subscriberMethods=subscriberMethodFinder.findSubscriberMethods(cls)
   {
	...findUsingReflection
           ...moveToSuperclass 		//从子类到父类都去查找注解信息
              ...findUsingReflectionInSingleClass 
		-> 检查参数是否只有一个 -> getAnnotation -> 获取Subscribe注解信息 -> 生成subscriberMethod
   }	

   >for(subscriberMethod in subscriberMethods)
    {
  	subscribe(subscriber,subscriberMethod)
	  ...Class<?> eventType = subscriberMethod.eventType;//获取订阅的事件类型
	     subscription newSubscription = new Subscription(subscriber, subscriberMethod)
	     val subscriptions=subscriptionsByEventType.get(eventType)
	     if(subscriptions.contains(newSubscription))//检查1！！！
		throw new Error
	     subscriptionsByEventType.put(eventType,subscriptions)
	  
	  ...List<Class<?>> events=typesBySubscriber.get(subscriber)//获取订阅者监听的所有消息
	     events.add(eventType)    
    }

   >public void post(Object event)
    {
	..PostingThreadState postingState=currentPostingThreadState.get()//ThreadLocal变量保存
	  List<Object> eventQueue=postingState.eventQueue
	  eventQueue.add(event)

	..if(!postingState.isPosting)
	  {
	    postingState.isMainThread=Looper.getMainLooper()==Looper.myLooper()
	    try{
		while(!eventQueue.isEmpty())
		  postingSingleEvent(eventQueue.remove(0),postingState)//发送单个事件!!!
		     ...//查找eventClass类所有的父类以及接口
            		List<Class<?>> eventTypes = lookupAllEventTypes(eventClass)
			for(clazz in eventTypes)
			{
			  postSingleEventForEventType(event , postingState , clazz )
			  -> CopyOnWriteArrayList<Subscription> subscriptions
			     subscriptions=subscriptionsByEventType.get(clazz)
			     for(subscription in subscriptions)
				postToSubscription(subscription, event, postingState.isMainThread)
				..区别一下主进程的派送方式 -> 根据getMainLooper创建handler再sendMessage
			}
	    }catch(){}
	  }
    }

>public static EventBus getDefault() {
    if (defaultInstance == null) {
        synchronized (EventBus.class) {
            if (defaultInstance == null) {
                defaultInstance = new EventBus();
            }
        }
    }
    return defaultInstance;
}

 public void handleSomethingElse(Msg msg)		//Msg为普通po,handleSomethingElse名字不固定
 {
….
 }

 List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass){
List<SubscriberMethod> subscriberMethods=METHOD_CACHEA.get(subscriberClass)
    if(subscriberMethods!=null)	return subscriberMethods
    subscriberMethods=findUsingReflection(subscriberClass)
    METHOD_CACHE.put(subscriberClass, subscriberMethods);
    Return subscriberMethods
 }

 private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
    //FindState 用来做订阅方法的校验和保存
    FindState findState = prepareFindState();
    findState.initForSubscriber(subscriberClass);
    while (findState.clazz != null) {
        //通过反射来获得订阅方法信息
        findUsingReflectionInSingleClass(findState);
        //查找父类的订阅方法
        findState.moveToSuperclass();
    }
    //获取findState中的SubscriberMethod(也就是订阅方法List)并返回
    return getMethodsAndRelease(findState);
}

  private void findUsingReflectionInSingleClass(FindState findState){
Method[] methods
    try{
  methods=findState.clazz.getDeclaredMethods()//通过反射获取方法
}
catch(Throwable th){}
//遍历Method
    for (Method method : methods) {
   int modifiers = method.getModifiers();
   if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) 
   {
      Class<?>[] parameterTypes = method.getParameterTypes();
      //保证必须只有一个事件参数
          if (parameterTypes.length == 1) {
	//获取注解
	Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class)
	if (subscribeAnnotation != null) {
               Class<?> eventType = parameterTypes[0];
                 
               ThreadMode threadMode = subscribeAnnotation.threadMode();
               //实例化SubscriberMethod对象并添加
               findState.subscriberMethods.add(new SubscriberMethod(method, eventType,
		threadMode,
                    subscribeAnnotation.priority(), 
		subscribeAnnotation.sticky()));
                  
             }
      }
   }
}
  }

    public @interface Subscribe{
       ThreadMode threadMode() default ThreadMode.POSTING;
       boolean sticky() default false;
       int priority() default 0;
    }
>>subscribe //注册方法
  :1.private void subscribe(Object subscriber, SubscriberMethod subscriberMethod)
     {
	//获取订阅的事件类型
        Class<?> eventType = subscriberMethod.eventType;
	//创建Subscription对象
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod)
	CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
	if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
	    //一个类只能监听一个事件一次
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }
	//根据优先级priority来添加Subscription对象
        int size = subscriptions.size();
        for (int i = 0; i <= size; i++) {
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
                subscriptions.add(i, newSubscription);
                break;
            }
        }
	//将订阅者对象以及订阅的事件保存到typesBySubscriber里,以便后续取消订阅
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber)
	if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
	//区别sticky事件，如果为sticky事件则立即分发
	if(subscriberMethod.sticky){
	  if(eventInheritance)//是否考虑监听事件的父类也作为事件去监听
	  {}
	  else{
	      Object stickyEvent = stickyEvents.get(eventType)//stickEvents为全局对象
              checkPostStickyEventToSubscription(newSubscription, stickyEvent)
	  }
	}
     }

 final static class PostingThreadState {
    final List<Object> eventQueue = new ArrayList<Object>();
    boolean isPosting;
    boolean isMainThread;
    Subscription subscription;
    Object event;
    boolean canceled;
  }

{
PostingThreadState postingState = currentPostingThreadState.get()//ThreadLocal变量
List<Object> eventQueue = postingState.eventQueue 
eventQueue.add(event)
if (!postingState.isPosting) {
      postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
      postingState.isPosting = true;
      if (postingState.canceled) {
        throw new EventBusException("Internal error. Abort state was not reset");
      }
      try {
        while (!eventQueue.isEmpty()) {
            postSingleEvent(eventQueue.remove(0), postingState)//发送事件
        }
      } finally {
        postingState.isPosting = false;
        postingState.isMainThread = false;
      }
   } 

 }

 private void postSingleEvent(Object event, PostingThreadState postingState)
 {
 Class<?> eventClass = event.getClass()
 boolean subscriptionFound = false
 if(eventInheritance)
 {
    List<Class<?>> eventTypes = lookupAllEventTypes(eventClass)//将事件类和其父类都加入链表
    int countTypes = eventTypes.size()
    for (int h = 0; h < countTypes; h++) {
            Class<?> clazz = eventTypes.get(h);
            subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
        }
 }

 }

 private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass)
 {
CopyOnWriteArrayList<Subscription> subscriptions
synchronized(this){
  subscriptions=subscriptionsByEventType.get(eventClass)
}
   if (subscriptions != null && !subscriptions.isEmpty()) {
  for(Subscription subscription:subscriptions)
  {  
     postingState.event=evnet
     postingState.subscription=subscription
     postToSubscription(subscription,event,postingState.isMainThread)
  }
  return ture
}
return false
 }

{
switch(subscription.subscriberMethod.threadMode)
{
  case ThreadMode.POSTING:
    invokeSubscriber(subscription,event) ->
    >try{
       subscription.subscriberMethod.method.invoke(subscription.subscriber,event)
     }catch(e)
     {}
    break;
  case ThreadMode.MAIN:
    if (isMainThread) {
          invokeSubscriber(subscription, event);		    //如果post线程就是主线程
        } else {
          mainThreadPoster.enqueue(subscription, event);
        }
    break;
      case BACKGROUND:
        if (isMainThread) {
            backgroundPoster.enqueue(subscription, event);
        } else {
            invokeSubscriber(subscription, event);
        }
        break;
}
 }	

 class HandlerPoster extends Handler{
private final PendingPostQueue queue
private EventBus eventBus
…
HandlerPoster(EventBus eventBus,Looper looper,..)
{
  super(looper)
  this.eventBus=eventBus
}

void enqueue(Subscription subscription,Object event)
{
  PendingPost pendingPost=PendingPost.obtainPendingPost(subscription,event)
  synchronized(this)
  {
    queue.enqueue(pendingPost)
    if(!handlerActive)
    {
      handlerActive=true
      sendMessage(obtainMessage())
    }
  }
}

@Override
public void handleMessage(Message msg)
{
  PendingPost pendingPost = queue.poll()
  if (pendingPost == null) {	//此时没有消息
        synchronized (this) {
           // Check again, this time in synchronized
           pendingPost = queue.poll();
           if (pendingPost == null) {
                 handlerActive = false;
                 return;
           }
        }
      }
   eventBus.invokeSubscriber(pendingPost)
}

 }

     final class BackgroundPoster implements Runnable{

     }
>>sticky事件
  public void postSticky(Object event) {
    synchronized (stickyEvents) {
        stickyEvents.put(event.getClass(), event);
    }
    // Should be posted after it is putted, in case the subscriber wants to remove immediately
    post(event)
  }

>>executorService = Executors.newCachedThreadPool()

>>eventTypesCache		//Map, List>> 
  a).

>>public class Singleton {
    private static Singleton instance;
    private Singleton (){}

    public static Singleton getInstance() {
     if (instance == null) {
         instance = new Singleton();
     }
     return instance
    }
  }

>>public static synchronized Singleton getInstance() //效率浪费,单例对象只有在创建阶段才需要同步
  {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
  }

>>public class SafeDoubleCheckedLocking {
    private volatile static Instance instance;

    public static Instance getInstance() {
        if (instance == null) {
           synchronized (SafeDoubleCheckedLocking.class) {
             if (instance == null)
               instance = new Instance();//此句会出现问题，因为构造函数存在多次赋值，而第1层检测是允许重入的,
						 //所以其它线程可能会去引用一个未初始化完成的对象，造成系统崩溃
						//加入volatile后保证在多线程环境下对变量的写 *** 作优先于读 *** 作
            }
        }
        return instance;
    }
  }

    a).static class Entry extends WeakReference<ThreadLocal<?>> {
	
	  Object value;
	  Entry(ThreadLocal<?>k,Object v)
	  {
	    super(k)
	    value=v
	  }
       }
    b).private Entry[] table	//Entry表
    c).private static final int INITIAL_CAPCITY=16		//必须为2的幂
    d).ThreadLocalMap(ThreadLocal<?> firstKey,Object firstValue)
	{
	  table=new Entry[INITIAL_CAPACITY]
	  int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)
		//当新建ThreadLocal实例时会生成threadLocalHashCode，主要针对ThreadLocal的开地址解决冲突策略
          // 初始化该节点
          table[i] = new Entry(firstKey, firstValue);
	}
       
    e).线性探查
      >寻找下个索引
       private static int nextIndex(int i ,int len)
       {
	  return i+1<len?i+1:0
       }
      >寻找上个索引
       private static int prevIndex(int i ,int len)
       {
	 return i-1>=0?i-1:len-1
       } 
   g).获取元素
     > getEntry(ThreadLocal<?> key)
       {
         int i=key.threadLocalHashCode & table.length-1
         Entry e=table[i]
         if(e!=null&&e.get()==key)
	   return e
         while(e!=null)
         {
	   ThreadLocal<?>k = e.get()
	   if(k==key)
	     return e
	   if(k==null)	//弱引用被垃圾回收
	     expungeStaleEntry(i)		//清理staleEntry
	   else
	     i=nextIndex(i,len)
	   e=tab[i]
         }
       }
    > expungeStaleEntry(int slot)		//清理槽
      {
	Entry[] tab=table
	int len=tab.length
	tab[slot].value=null
	tab[slot]=null
	//遇到空的entry即停止
	for(int i=nextIndex(slot,len);(e=tab[i])!=null;i=nextIndex(i,len))
	{
	  ThreadLocal<?> k=e.get()
	  if(k==null)
	  {
	     e.value=null
	     tab[i]=null
	  }
	  else{
	    //get the hash of this new slot
	    int h= k.threadLocalHashCode()&(len-1)
	    if(h!=i)//rehash,鉴于该hash有可能是基于线性探查才决定的位置
            {
	      tab[i]=null
	      while(tab[h]!=null){
		h=nextIndex(h,len)
	      }
	      tab[h]=e
	    }
	  }
	
	}
      }
    h).设置元素
     > private void set(ThreadLocal<?> key,Object value)
       {
	 Entry[] tab=table
	 int len=tab.length
 	 int i= key.threadLocalHashCode & (len-1)
	 for(Entry e=tab[i]; e!=null ;e=tab[i=nextIndex(i,len)])
	 {
	   ThreadLocal<?> k=e.get()
	   if(k==key)
	     e.value=value
	     return
	   if(k==null)//该entry的引用已被GC回收
	     replaceStaleEntry(key, value ,i)
	     return
	 }
       }
     > 取代旧有的entry
       private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
	 Entry[] tab=table
	 int len=tab.length
	 
	 for(int i=nextIndex(staleSlot,len);(e=tab[i])!=null;i=nextIndex(i,len))
	 {
	   ThreadLocal<?> k= e.get()
	   if(k==key)
	   {
	     e.value=value
	     //交换空槽和匹配的槽
	     tab[i]=tab[staleSlot]
	     tab[staleSlot]=e
           }
	 }

       }
 

>>ThreadLocal
  a).ThreadLocal::ThreadLocal()
  b).public T get()
     {
	Thread t=Thread.currentThread()
	ThreadLocalMap map=t.getMap(t)
	if(map!=null)
	{
	  ThreadLocalMap.Entry e=map.getEntry(this)
	  if(e!=null)
	  {
	    T result=(T)e.value
	    return result
	  }
	}
	return setInitialValue()
     }
  c).private Entry getEntry(ThreadLocal<?> key)
     {
	int i = key.threadLocalHashCode & (table.length - 1)
	Entry e=table[i]
	if (e != null && e.get() == key)
           return e
	else
	    return getEntryAfterMiss(key, i, e)
     }
  d).private Entry getEntryAfterMiss(ThreadLocal<?> key,int i,Entry e
  c).ThreadLocal::set(T)
  d).ThreadLocal::remove()
>>set					//
b).ThreadLocal.set()  => Thread t= Thread.currentThread();  ThreadLocalMap map=getMap(t);
c).当ThreadLocal初始化时,会自动调用nextHashCode生成，以便随后根据hashCode进行数组元素的索引
d).如果当前thread的threadLocalMap不为空 => map.set(this,value)
   如果为空 => createMap
   >>t.threadLocals= new ThreadLocalMap(this,firstValue);
>>//实例
  ThreadLocal<String> name=new ThreadLocal<>();  
  name.set(“dancing”)

  >  <resources>
       <!--name为声明的"属性集合"名，可以随便取，但是最好是设置为跟我们的View一样的名称-->
    	<declare-styleable name="MyView">
          <!--声明我们的属性，名称为default_size,取值类型为尺寸类型（dp,px等）-->
          <attr name="default_size" format="dimension" />
       </declare-styleable>
     </resources>

   {  
        super(context, attrs, defStyle);  
        /** 
         * 获得我们所定义的自定义样式属性 
         */  
        TypedArray a = context.getTheme().obtainStyledAttributes(attrs, R.styleable.CustomTitleView, defStyle, 0);  
        int n = a.getIndexCount();  
        for (int i = 0; i < n; i++)  
        {  
            int attr = a.getIndex(i);  
            switch (attr)  
            {  
            case R.styleable.CustomTitleView_titleText:  
                mTitleText = a.getString(attr);  
                break;  
            case R.styleable.CustomTitleView_titleTextColor:  
                // 默认颜色设置为黑色  
                mTitleTextColor = a.getColor(attr, Color.BLACK);  
                break;  
            case R.styleable.CustomTitleView_titleTextSize:  
                // 默认设置为16sp，TypeValue也可以把sp转化为px  
                mTitleTextSize = a.getDimensionPixelSize(attr, (int) TypedValue.applyDimension(  
                        TypedValue.COMPLEX_UNIT_SP, 16, getResources().getDisplayMetrics()));  
                break;  
  
            }  
  
        }  
        a.recycle();  
  
        /** 
         * 获得绘制文本的宽和高 
         */  
        mPaint = new Paint();  
        mPaint.setTextSize(mTitleTextSize);  
        // mPaint.setColor(mTitleTextColor);  
        mBound = new Rect();  
        mPaint.getTextBounds(mTitleText, 0, mTitleText.length(), mBound);  
  
    } 

>>@Override
  protected void onMeasure(int widthMeasureSpec,int heightMeasureSpec)
  {
    super.onMeasure(widthMeasureSpec,heightMeasureSpec);  
    //当自定义view采用wrap_content匹配时需要重写     a).setMeasuredDimension(width,height)
  }

>>@Override
  protected void onDraw(Canvas canvas)
  {
    mPaint.setColor(Color.YELLOW);  
    canvas.drawRect(0, 0, getMeasuredWidth(), getMeasuredHeight(), mPaint); 
  }

>>final Semaphore semaphore=new Semaphore(1)//资源数量为1
  semaphore.acquire()	//相当于P *** 作
  semaphore.release()	//相当于V *** 作
>>例子
  final Semaphore sema = new Semaphore(3);
  for (int index = 1; index < 10; index++) {
     new Thread(new Runnable(){
	@Override 
	public void run (){
	  sema.acquire()
	  //todo...
	  sema.release()
  	}

     })
  } 

    > class Outputter {
	private Lock lock = new ReentrantLock(); // 定义锁对象
 
	public void output(String text) throws InterruptedException {
		lock.lock(); // 得到锁
		try {
	          for (int i = 0; i < text.length(); i++) {
		    System.out.println(text.charAt(i));
		    Thread.sleep(1000);
		  }
		} finally {
		  lock.unlock(); // 释放锁
		}
	}
      }
  :2.ReadWriteLock//读写锁
    >class Data {
	private int data;
	private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
 
	public void set(int data) throws Exception {
		readWriteLock.writeLock().lock(); // 获取写锁
		try {
		  Thread.sleep(50); // 模拟耗时 *** 作
		  this.data = data;
		} finally {
	          readWriteLock.writeLock().unlock(); // 释放写锁
		}
	}
	public void get() throws Exception {
	  readWriteLock.readLock().lock(); // 获取读锁
	  try {
	    Thread.sleep(50); // 模拟耗时 *** 作
	  } finally {
	    readWriteLock.readLock().unlock(); // 释放读锁
	  }
	}
     }