Android Studio--从Java线程到安卓线程

写在前面：

本文为安卓线程与JAVA线程的异同，请多多指正！

简述：

相信很多学安卓的都是从java入门之后开始进行安卓的学习，而当我们面临安卓线程的书写的时候，发现安卓线程并不是我们想象中使用java的线程写法就可以。

• java线程的语法移植出错了？

这里我们简单的书写一个TextClock（由TextView 和Calendar组成），这里的Button用于终止时间。这里我们使用java上线程的写法来：

public class MainActivity extends AppCompatActivity {

    private TextView textView;
    private boolean flag = true;//用于控制线程
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(flag){
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTimeInMillis(System.currentTimeMillis());
                    int hour = calendar.get(Calendar.HOUR_OF_DAY);
                    int minute = calendar.get(Calendar.MINUTE);
                    int sec = calendar.get(Calendar.SECOND);
                    String string = new String(hour + " : " + minute + " : " + sec);
                    textView = (TextView)findViewById(R.id.test);
                    textView.setText(msg.obj.toString());
                    try{
                        Thread.currentThread().sleep(100);
                    }catch(Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        Button button = (Button)findViewById(R.id.Btn);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                flag = false;
                Toast.makeText(MainActivity.this,"You click here!",Toast.LENGTH_SHORT).show();
            }
        });
    }
}

　　现在分析一下上面的案例，在上面的程序中有两个线程：一个主线程和一个子线程，它们的职责如图所示。

上述实例中的处理利用子线程进行了UI界面的更新，违背了Android多线程编程规则，系统会抛出异常“Only the original thread that created a view hierarchy can touch its views”。

要解决这个问题，就要明确主线程和子线程的职责。主线程的职责是创建、显示和更新UI控件、处理UI事件、启动子线程、停止子线程;子线程的职责是计算逝去的时间和向主线程发出更新UI消息，而不是直接更新UI。

主线程的职责是显示UI控件、处理UI事件、启动子线程、停止子线程和更新UI，子线程的职责是计算逝去的时间和向主线程发出更新UI消息。但是新的问题又出现了：子线程和主线程如何发送消息、如何通信呢?

• 利用Handler和message处理子进程
  由于布局很简单，我们这里不进行布局代码的阐述，以下为主活动代码：

public class MainActivity extends AppCompatActivity {

    private TextView textView;
    private boolean flag = true;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        /*使用Handler进行更新页面*/
        final android.os.Handler handler = new android.os.Handler(){
            @Override
            public void handleMessage(Message msg) {
                switch(msg.what){/*接收来自子线程之间的message*/
                    case 0:{/*根据来源执行不同的操作*/
                        textView = (TextView)findViewById(R.id.test);
                        textView.setText(msg.obj.toString());/*文本更新*/
                    }
                }
                super.handleMessage(msg);
                //这里最好对不需要或者不关心的消息抛给父类，避免丢失消息  
            }
        };
        new Thread(new Runnable() {//利用Runnable接口实现线程
            @Override
            public void run() {
                while(flag){
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTimeInMillis(System.currentTimeMillis());
                    int hour = calendar.get(Calendar.HOUR_OF_DAY);
                    int minute = calendar.get(Calendar.MINUTE);
                    int sec = calendar.get(Calendar.SECOND);
                    String string = new String(hour + " : " + minute + " : " + sec);
                    //上述为计算操作
                    Message message = new Message();//初始化消息对象
                    message.obj = string;//将想要发送的消息添加到消息中
                    message.what = 0;//设置message来源为0
                    handler.sendMessage(message);//给handler发送消息
                    try{//线程休眠
                        Thread.currentThread().sleep(100);
                        //Thread代表线程,currentThread()代表获取当前线程,sleep()代表睡眠
                    }catch(Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        Button button = (Button)findViewById(R.id.Btn);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                flag = false;
                Toast.makeText(MainActivity.this,"You click here!",Toast.LENGTH_SHORT).show();
            }
        });
    }
}

更加具体的消息机制请访问
Android的Message机制（简单小结） - ·没有风雨躲得过，没有坎坷不必走· - 博客频道 - CSDN.NET
http://blog.csdn.net/dadoneo/article/details/7667726

这样子我们就简单的做了一个计时器app，利用线程成功实现了计时并更新数据。

• 利用TimeTask和Handler实现
  在Android平台中需要反复按周期执行方法可以使用Java上自带的TimerTask类，TimerTask相对于Thread来说对于资源消耗的更低，除了使用Android自带的AlarmManager使用Timer定时器是一种更好的解决方法。 我们需要引入import java.util.Timer; 和 import java.util.TimerTask;

public class MainActivity extends AppCompatActivity {

    private TextView textView;
    private android.os.Handler handler;
    private boolean flag = true;
    Timer timer = new Timer();//实例化Timer
    TimerTask timerTask = new TimerTask() {//实例化TimerTask
        @Override
        public void run() {
            Calendar calendar = Calendar.getInstance();
            calendar.setTimeInMillis(System.currentTimeMillis());
            int hour = calendar.get(Calendar.HOUR_OF_DAY);
            int minute = calendar.get(Calendar.MINUTE);
            int sec = calendar.get(Calendar.SECOND);
            String string = new String(hour + " : " + minute + " : " + sec);
            Message message = new Message();//实例消息
            message.obj = string;
            message.what = 0;
            handler.sendMessage(message);
        }
    };


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        handler = new android.os.Handler(){
            @Override
            public void handleMessage(Message msg) {
                switch(msg.what){
                    case 0:{
                        textView = (TextView)findViewById(R.id.test);
                        textView.setText(msg.obj.toString());
                    }
                }
                super.handleMessage(msg);
            }
        };
        timer.schedule(timerTask,1000,100);//注释一

        Button button = (Button)findViewById(R.id.Btn);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                flag = false;
                Toast.makeText(MainActivity.this,"You click here!",Toast.LENGTH_SHORT).show();
            }
        });
    }
}

[ 注释一 ]：timer.schedule(new MyTask(),long time1,long timer2);
第一个参数，是 TimerTask 类，在包：import java.util.TimerTask .使用者要继承该类，并实现 public void run() 方法，因为 TimerTask 类 实现了 Runnable 接口。
第二个参数的意思是，当你调用该方法后，该方法必然会调用 TimerTask 类 TimerTask 类 中的 run() 方法，这个参数就是这两者之间的差值，转换成汉语的意思就是说，用户调用 schedule() 方法后，要等待这么长的时间才可以第一次执行 run() 方法。
第三个参数的意思就是，第一次调用之后，从第二次开始每隔多长的时间调用一次 run() 方法。
[附：]
　　技术人员在实现内部办公系统与外部网站一体化的时候，最重要的步骤就是从OA系统读取数据，并且根据网站模板生成最终的静态页面。这里就需要一个定时任务，循环的执行。
　　技术人员在写定时任务的时候，想当然的以为Timer.schedule(TimerTask task, long delay)就是重复的执行task。程序运行后发现只运行了一次，总觉得是task里的代码有问题，花了很长时间调试代码都没有结果。
　　仔细研读java api，发现：
　　schedule(TimerTask task, long delay)的注释：Schedules the specified task for execution after the specified delay。大意是在延时delay毫秒后执行task。并没有提到重复执行
　　schedule(TimerTask task, long delay, long period)的注释：Schedules the specified task for repeated fixed-delay execution, beginning after the specified delay。大意是在延时delay毫秒后重复的执行task，周期是period毫秒。
　　这样问题就很明确schedule(TimerTask task, long delay)只执行一次，schedule(TimerTask task, long delay, long period)才是重复的执行。关键的问题在于程序员误以为schedule就是重复的执行，而没有仔细的研究API，一方面也是英文能力不够，浏览API的过程中不能很快的理解到含义。

• 知识点补充

很多初入Android或Java开发的新手对Thread、Looper、Handler和Message仍然比较迷惑，衍生的有HandlerThread、java.util.concurrent、Task、AsyncTask由于目前市面上的书籍等资料都没有谈到这些问题，今天就这一问题做更系统性的总结。我们创建的Service、Activity以及Broadcast均是一个主线程处理，这里我们可以理解为UI线程。但是在操作一些耗时操作时，比如I/O读写的大文件读写，数据库操作以及网络下载需要很长时间，为了不阻塞用户界面，出现ANR的响应提示窗口，这个时候我们可以考虑使用Thread线程来解决。

对于从事过J2ME开发的程序员来说Thread比较简单，直接匿名创建重写run方法，调用start方法执行即可。或者从Runnable接口继承，但对于Android平台来说UI控件都没有设计成为线程安全类型，所以需要引入一些同步的机制来使其刷新，这点Google在设计Android时倒是参考了下Win32的消息处理机制。

1. 对于线程中的刷新一个View为基类的界面，可以使用postInvalidate()方法在线程中来处理，其中还提供了一些重写方法比如postInvalidate(int
   left,int top,int right,int bottom)
   来刷新一个矩形区域，以及延时执行，比如postInvalidateDelayed(long
   delayMilliseconds)或postInvalidateDelayed(long delayMilliseconds,int
   left,int top,int right,int bottom) 方法，其中第一个参数为毫秒

2. 当然推荐的方法是通过一个Handler来处理这些，可以在一个线程的run方法中调用handler对象的 postMessage或sendMessage方法来实现，Android程序内部维护着一个消息队列，会轮训处理这些，如果你是Win32程序员可以很好理解这些消息处理，不过相对于Android来说没有提供
   PreTranslateMessage这些干涉内部的方法。

3. Looper又是什么呢? ，其实Android中每一个Thread都跟着一个Looper，Looper可以帮助Thread维护一个消息队列，但是Looper和Handler没有什么关系，我们从开源的代码可以看到Android还提供了一个Thread继承类HanderThread可以帮助我们处理，在HandlerThread对象中可以通过getLooper方法获取一个Looper对象控制句柄，我们可以将其这个Looper对象映射到一个Handler中去来实现一个线程同步机制，Looper对象的执行需要初始化Looper.prepare方法就是昨天我们看到的问题，同时推出时还要释放资源，使用Looper.release方法。

4. Message 在Android是什么呢?
   对于Android中Handler可以传递一些内容，通过Bundle对象可以封装String、Integer以及Blob二进制对象，我们通过在线程中使用Handler对象的sendEmptyMessage或sendMessage方法来传递一个Bundle对象到Handler处理器。对于Handler类提供了重写方法handleMessage(Message
   msg)
   来判断，通过msg.what来区分每条信息。将Bundle解包来实现Handler类更新UI线程中的内容实现控件的刷新操作。相关的Handler对象有关消息发送sendXXXX相关方法如下，同时还有postXXXX相关方法，这些和Win32中的道理基本一致，一个为发送后直接返回，一个为处理后才返回
   .

5. java.util.concurrent对象分析，对于过去从事Java开发的程序员不会对Concurrent对象感到陌生吧，他是JDK 1.5以后新增的重要特性作为掌上设备，我们不提倡使用该类，考虑到Android为我们已经设计好的Task机制，这里不做过多的赘述，相关原因参考下面的介绍:

6. 在Android中还提供了一种有别于线程的处理方式，就是Task以及AsyncTask，从开源代码中可以看到是针对Concurrent的封装，开发人员可以方便的处理这些异步任务。

摘录自：http://www.cnblogs.com/playing/archive/2011/03/24/1993583.html