View,SurfaceView,SurfaceHolder

View：对于绘画来说，最重要的步骤是重载 onDraw方法并且修改画布Canvas。

SurfaceView：1，You can control the format of this surface and, if you like, its size;

                    2，One of the purposes of this class is to provide a surface in which a secondary thread can render into the screen.

SurfaceView 和 View 的主要区别：

1,SurfaceView 可以在主线程和非主线程中更新UI显示，也就是SurfaceView直接控制最顶层屏幕中可见的Canvas.

   所以SurfaceView适用于系统自动计算的被动更新，而View适用于需要用户互动的主动更新。

  SurfaceHolder 是对SurfaceView对象的控制。比如修改大小，屏幕改变事件等，需要设置SurfaceHolder.Callback接口

2,SurfaceView 更新画面的速度较View快,因为SurfaceView的“画布”surface比View的画布canvas更底层。

下面是两个视图的代码对比：

public class MainActivity extends Activity {

    
   private Thread mThread =null;
   private MogulView mView=null;
   private MogulSurfaceView mSurfaceView=null;
   private final int MSG_REFRESH_VIEW =0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //使用surfaceView可以直接在非主线程中更新canvas;
        // setContentView(new MogulSurfaceView(this));
        
        //在非主线程中更新View的时候需要调用到hanler 协助更新View视图
        mView =new MogulView(this);
        setContentView(mView);
        startViewRender();
        
    }
    
    //用于协助其他线程更新View中的Canvas
    private Handler mHandler =new Handler(){

        @Override
        public void handleMessage(Message msg) {
            if(msg.what ==MSG_REFRESH_VIEW){
                //to refresh view 
                if(mView !=null)
                    mView.invalidate();
            }
        }
        
    };
    
    public void startViewRender(){
        mThread =new Thread(new Runnable()
        {

            @Override
            public void run() {
                while(true){
                    try{
                        //
                        Thread.sleep(1000);
                    }
                    catch(Exception e){
                        
                    }
                    finally{
                        mHandler.sendEmptyMessage(MSG_REFRESH_VIEW);
                    }
                }
               
            }
        });
        mThread.start();
    }
    
    
    class MogulView extends View{
        int r =10;
        public MogulView(Context context) {
            super(context);
            // TODO Auto-generated constructor stub
        }

        //重载View中的canvas
        @Override
        protected void onDraw(Canvas canvas) {
            super.onDraw(canvas);
            if(r<=100)
                r+=10;
            else
                r =10;
            Paint paint =new Paint();
            paint.setColor(Color.RED);
            canvas.drawCircle(150, 150, r, paint);
        }
        
        
    }
    
    
    class MogulSurfaceView extends SurfaceView implements SurfaceHolder.Callback{

        private SurfaceHolder mSurfaceHolder =null; 
        private MogulThread mThread =null;
        public MogulSurfaceView(Context context) {
            super(context);
            mSurfaceHolder =this.getHolder();
            mSurfaceHolder.addCallback(this);
            mThread =new MogulThread(mSurfaceHolder);
          
        }

        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            // TODO Auto-generated method stub
            mThread.isRun=true;
            mThread.start();
        }

        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
            // TODO Auto-generated method stub
            
        }

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            mThread.isRun=false;
            mThread.stop();
        }
        
    }
    class MogulThread extends Thread{
        private SurfaceHolder mSurfaceHolder =null; 
        private boolean isRun =false;
        MogulThread( SurfaceHolder holder){
            this.mSurfaceHolder=holder;
            isRun =true;
        }
        //直接在非主线程中更新Canvas
        @Override
        public void run() {
            Canvas canvas=null;
            int count =0;
            while(true){
                try{
                    
                    synchronized (mSurfaceHolder) {
                        canvas =mSurfaceHolder.lockCanvas();
                        canvas.drawColor(Color.BLACK);
                        Paint paint=new Paint();
                        paint.setColor(Color.RED);
                        Rect rect =new Rect(500,200,250,300);
                        canvas.drawRect(rect, paint);
                        canvas.drawText("程序已经运行了："+count+"秒", 100, 100, paint);
                        Thread.sleep(1000);
                        count++;
                        
                    }
                }
                catch(Exception e){
                    e.printStackTrace();
                }
                finally{
                    if(canvas!=null){
                        mSurfaceHolder.unlockCanvasAndPost(canvas);
                    }
                }
            }
        }
        
        
    }
    
   
    
    
    
    
}