android线程之多线程

相信大家对于什么是android进程和线程的理论应该都有所了解了，不清楚的可以查看这篇文章
android进程和线程
下面进一步学习，如何实现线程和多线程
什么是单线程，什么是多线程？先看这张图

多线程：它是一组指令的集合，在控制流程语句当中，每一个线程就是一条控制语句，线程与线程之间是可以实现数据共享的，所谓多线程，在某一个时间片段同时有多个任务在一起执行。
线程运行过程中的生命周期

这里不细讲过程
下面才是重点，线程实现的方法，我们先看看java里的线程
java实现线程有两种方式：
■继承Thread类
步骤如下：
1、定义一个普通类去继承Thread类，则表明此类是一个线程类。
语法结构：

public class 类名 extends Thread{}

2、重写父类中的run方法
语法结构：

public void run() {
                    //线程的执行体
                }

3、使用线程
调用start方法来执行线程
语法结构：
线程对象名.start();
■实现Runnable接口
步骤如下
1、定义普通类去实现Runnable接口
语法结构：

public class 类名 implements Runnable{}

2、重写run方法
3、启动线程

-定义自己的线程对象

MyThread myThread = new MyThread();

-定义系统的线程对象,把自己的线程对象作为参数传递到系统的线程对象

Thread thread = new Thread(myThread);

-调用start方法执行:thread.start()
当然这两个方式是有区别和优缺点的
采用继承Thread类方式：
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。
采用实现Runnable接口方式：
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。
我们再来看看android的线程
Android和Java一样，它支持使用Java里面的Thread类来进行一步任务处理。所以可以轻松地像上面Java的例子一样来使用Android上的线程，
但是在
android进程和线程
文章里说过
Android UI工具包不是线程安全的。所以，你不能从一个工作线程中操作你的用户界面，你必须从用户界面中对用户界面做所有的操作。因此，有简单的规则，以Android的单线程模型：
•不要阻塞用户界面线程
•不访问用户界面线程以外的安卓用户界面工具包
所以android的线程实现方式跟java一样有两种，但是处理方法有区别
下面我们来看看
说到线程不得说Handler，它是线程间通信的桥梁，Handler的细节在这里
android的消息处理机制
我们直接上程序
Handler消息处理机制

public class MyHandler extends Handler{
        public void handleMessage(Message msg){
                switch(msg.what){
                case   1  :   
                            //处理消息，例如更新UI
                    break；
                case   2  ：
                            //处理消息
                    break；
                default ： break；
                }
        }
}

或者可以这样写

Handler mHandler = new Handler(){
        public void handleMessage(Message msg){
                switch(msg.what){
                case   1  :   
                            //处理消息，例如更新UI
                    break；
                case   2  ：
                            //处理消息
                    break；
                default ： break；
                }
        }
}

然后 通过new得到一个对象实例

MyHandler mHandler = new MyHandler();

向消息队列发送消息可以使用下列方法发送

mHandler.sendMessage(message);
mHandler.postDelayed(Runnable r, long delayMillis);
mHandler.sendEmptyMessage(int what);
mHandler.sendMessage(Message msg);
mHandler.sendEmptyMessageAtTime(int what, long uptimeMillis);

然后开始创建线程
方式一：继承Thread类
步骤和java创建差不多，直接上程序

public class MyThread extends Thread{
    public void run(){
        //消息执行体，创建消息并发送到消息队列就在这里发送，如：
        Message message =new Message();//得到一个消息对象
        message.what=1;//给消息做标记，当handler获取消息时就知道是那个
        message.obj=msg;//需要发送的数据
        mHandler.sendMessage(message);//向消息队列里加入消息
    }
}

开启线程的方法

MyThread myThread = new MyThread();//new一个线程对象
myThread.start();//使用start()方法启动线程

注意：不一定run()方法里的message都是用上面的方法创建，看情况而定

方式二：实现Runnable接口
直接上程序

public MyRunnable implements Runnable{
    public void run(){
        //消息执行体，创建消息并发送到消息队列就在这里发送，如：
        Message message =new Message();//得到一个消息对象
        message.what=1;//给消息做标记，当handler获取消息时就知道是那个
        message.obj=msg;//需要发送的数据
        mHandler.sendMessage(message);//向消息队列里加入消息
    }
}

注意：有时根据需要可以通过写构造函数传入参数
启动线程方法

MyRunnable myRunable = new MyRunnable();//得到一个Runnable对象
Thread thread = new Thread(myRunnable);//new一个thread并传入runnable对象
thread.start();//使用start()方法启动线程

有时候为了看起来紧凑可以这样写

new Thread(new Runnable(){
    public void run(){
        //消息执行体，创建消息并发送到消息队列就在这里发送，如：
        Message message =new Message();//得到一个消息对象
        message.what=1;//给消息做标记，当handler获取消息时就知道是那个
        message.obj=msg;//需要发送的数据
        mHandler.sendMessage(message);//向消息队列里加入消息
    }
}).start();

Runnable 并不一定是新开一个线程，比如下面的调用方法就是运行在UI主线程中的：

Handler mHandler=new Handler(); 
mHandler.post(new Runnable(){ 
    @Override 
    public void run() { 
        // TODO Auto-generated method stub 
    } 
});

Runnable是一个接口，不是一个线程，一般线程会实现Runnable。 所以如果我们使用匿名内部类是运行在UI主线程的，如果我们使用实现这个Runnable接口的线程类，则是运行在对应线程的。
这种情况下，由于不是在新的线程中使用，所以千万别做复杂的计算逻辑。
下面给出简单例子（经典的在UI中实现计时操作）
XML布局

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />
        <LinearLayout 
            android:id="@+id/my_lay"
            android:layout_below="@id/textView1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:orientation="vertical">

            <TextView
                android:id="@+id/textView2"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="TextView" />

        <Button
            android:id="@+id/button1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_below="@+id/textView1"
            android:layout_centerHorizontal="true"
            android:layout_marginTop="116dp"
            android:text="button" />


    </LinearLayout>
</RelativeLayout>

主程序
先做个简单的描述：
在这个例子里使用了上面的两种方式来创建线程，一个线程实现计时，一线程往TextView写入信息，Button按键按下计时停止

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;


public class MainActivity extends Activity {
    private final int MESSAGE_WHAT_1 = 1;//消息标记
    private final int MESSAGE_WHAT_2 = 2;
    private final int MESSAGE_WHAT_3 = 3;
    public Button btn1 = null;
    private TextView tv = null;
    private TextView tv1 = null;
    private boolean isRunning = true;//计时
    private int timer = 0;
    public Handler mHandler = null;
    private Thread mThread = null;
    private Thread mThread1 = null;
    private MyRunnable mRunnable = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);



         tv=(TextView)findViewById(R.id.textView1);
         tv1=(TextView)findViewById(R.id.textView2);
         btn1=(Button)findViewById(R.id.button1);
         btn1.setOnClickListener(new bt1Listener());

        mHandler =  new MyHandler(); 

        //线程1 
        mRunnable = new MyRunnable();
        mThread = new Thread(mRunnable);
        mThread.start();

        //线程2
        mThread1 = new MyThread();
        mThread1.start();
    }
    public class MyHandler extends Handler{
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MESSAGE_WHAT_2:
            //通过继承Thread类实现的线程更新UI
                String str1=msg.getData().getString("text1");
                String str2=msg.getData().getString("text2");
                tv.setText(str1 + " " + str2);
            case MESSAGE_WHAT_1:
            //通过实现Runnable来更新UI
                tv1.setText("逝去了:" + msg.obj);//经典的更新UI例子。在UI中计时
                break;
            default: break;
            }
        }
    }

//方法一：继承Thread类
    public class MyThread extends Thread{
        //private String data = "";
        public MyThread(){//通过构造函数来传入数据
        super();
        }
        public void run(){
            Message message=new Message();//new一个Message对象
            message.what = MESSAGE_WHAT_2;//给消息做标记
            Bundle bundle = new Bundle();    
            bundle.putString("text1","这个继承Thread类");  //往Bundle中存放数据  
            bundle.putString("text2","来更新UI");  //往Bundle中put数据  
            message.setData(bundle);//mes利用Bundle传递数据
            mHandler.sendMessage(message);//Handler将消息放入消息队列
        }
    }
//方法二：实现implements接口
    public class MyRunnable implements Runnable{
        @SuppressWarnings("static-access")
        public void run(){
            try {   

                while(isRunning){
                    Thread.currentThread().sleep(1000);
                    timer++;//加1计时
                    Message message = new Message();//new一个message对象
                    message.obj = timer;//将timer封装到消息里
                    message.what = MESSAGE_WHAT_1;//做标记
                    mHandler.sendMessage(message);//加入消息队列                
                }   
           } catch (InterruptedException e) {   
                Thread.currentThread().interrupt();   
           }   
        }
    }
    class bt1Listener implements OnClickListener{
        @Override
        public void onClick(View arg0) {
            // TODO Auto-generated method stub
            isRunning = false;
        }
    };  
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

}

效果图：


点击Button

其实android实现多线程的方法可采用runOnUiThread，post，handle，AsyncTask技术实现。
这里讲解的是使用handler，其他的由大家来。