Android开发中的多线程

最新推荐文章于 2024-09-11 16:42:23 发布

乔布尸

最新推荐文章于 2024-09-11 16:42:23 发布

阅读量973

点赞数

分类专栏： Android开发文章标签：多线程

Android开发专栏收录该内容

7 篇文章 0 订阅

订阅专栏

多线程案例——计时器

这个案例中，屏幕启动之后，进入如图所示的界面。

屏幕上有一个文本框用于显示逝去的时间，此外还有一个“停止计时”按钮。案例的用例图如图所示。

能够在屏幕上“实时地显示”时间的流逝，单线程程序是无法实现的，必须要多线程程序才可以实现，即便有些计算机语言可以通过封装好的类实现这一功能，但从本质上讲这些封装好的类就是封装了一个线程。

综上所述，完成本案例用到的知识及技术如下：

　　1)进程和线程的概念;

　　2)Java中的线程，在Java中创建线程的方式;

　　3)Android中的线程，包括：Message、Handler、Looper和HandlerThread等概念。

线程究竟是什么?在Windows操作系统出现之前，个人计算机上的操作系统都是单任务系统，只有在大型计算机上才具有多任务和分时设计。Windows、Linux操作系统的出现，把原本只在大型计算机才具有的优点，带到了个人计算机系统中。

进程概念

　　一般可以在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间、一组系统资源。在进程的概念中，每一个进程的内部数据和状态都是完全独立的。在Windows操作系统下我们可以通过〈Ctrl+Alt+Del〉组合键查看进程，在UNIX和Linux操作系统下是通过PS命令查看进程的。打开Windows当前运行的进程，如图所示。

在Windows操作系统中一个进程就是一个exe或dll程序，它们相互独立，互相也可以通信，在Android操作系统中进程间的通信应用也是很多的。

线程概念

　　多线程指的是在单个程序中可以同时运行多个不同的线程，执行不同的任务。多线程意味着一个程序的多行语句可以看上去几乎在同一时间内同时运行。

　　线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制。但与进程不同的是，同类的多个线程共享一块内存空间和一组系统资源，所以系统在各个线程之间切换时，资源占用要比进程小得多，正因如此，线程也被称为轻量级进程。一个进程中可以包含多个线程。图所示是计时器程序进程和线程之间的关系，主线程负责管理子线程，即子线程的启动、挂起、停止等操作。

Java中的线程

　　Java的线程类是java.lang.Thread类。当生成一个Thread类的对象之后，一个新的线程就产生了。Java中每个线程都是通过某个特定Thread对象的方法run()来完成其操作的，方法run( )称为线程体。

　　下面是构建线程类几种常用的方法：

　　public Thread()

　　public Thread(Runnable target)

　　public Thread(Runnable target, String name)

　　public Thread(String name)

　　参数target是一个实现Runnable接口的实例，它的作用是实现线程体的run()方法。目标target可为null，表示由本身实例来执行线程。name参数指定线程名字，但没有指定的构造方法，线程的名字是JVM分配的，例如JVM指定为thread-1、thread-2等名字。

1、Java中的实现线程体方式1

　　在Java中有两种方法实现线程体：一是继承线程类Thread，二是实现接口Runnable。下面我们先看看继承线程类Thread方式。

如果采用第1种方式，它继承线程类Thread并重写其中的方法 run()，在初始化这个类实例的时候，目标target可为null，表示由本实例来执行线程体。由于Java只支持单重继承，用这种方法定义的类不能再继承其他父类，例如代码清单如图：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class textThread extends Thread {
    boolean flag = true;
    int timer = 0;

    @Override
    public void run() {
        super.run();
        try {
            while (flag) {
                this.currentThread().sleep(1000);
                timer++;
                System.out.print(timer);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        textThread thread = new textThread();
        thread.start();
        System.out.print("启动计时器...");
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    
        try {
            String line = reader.readLine();
            if(line.equalsIgnoreCase("1")){
                //thread.stop();
                thread.flag = false;
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

在main主方法中通过new textThread（）创建子线程，并通过thread.start()方法启动子线程，main主方法所在线程为主线程，主线程负责管理其他的子线程。本例进程、主线程和子线程之间的关系如图所示。

　　子线程启动之后就开始调用run()方法，run()是一个线程体，我们在子线程中处理事情就是在这里编写代码实现的。本案例中子线程要做的事情就是：休眠1s，计时器加1，再反复执行。Thread.currentThread().sleep(1000)就是休眠1s。

　　为了能够停止线程，我们在主线程中增加了一个标识，通过在控制台输入一个字符

　　“1”来改变该标识t1.isRunning = false，从而结束这个线程。

注意：

　　事实上线程中有一个stop()方法也可以停止线程，但是由于这种方法会产生线程死锁问题，所以在新版JDK中已经废止了，它的替代解决方法就是增加标识，就是我们在本例中采用的方案。

　　很多人觉得线程难理解，主要有两个问题：

　　线程休眠，既然线程已经休眠了，程序的运行速度还能提高吗?

　　线程体一般都进行死循环，既然线程死循环，程序就应该死掉了，就会没有反应。

　　1.关于线程休眠问题

　　对线程休眠问题头痛的读者，其实还是在用单线程的思维模式考虑问题，多数情况下我们的PC都是单CPU的，某个时间点只能有一个线程运行。所谓多线程就是多个线程交替执行就好像同时运行似的。因此，休眠当前线程可以交出CPU控制权，让其他的线程有机会运行，多个线程之间只有交替运行效率才是最高的，这就像我们开车过十字路口，只有我等等，让你先过，你再等等让他先过，才能保证最高效率，否则就会造成交通系统崩溃，对线程情况也是一样的。因此，多线程中线程的休眠是程序运行的最有效方式。

　　2.关于线程体死循环问题

　　在单线程中如果是死循环，程序应就会死掉，没有反应，但是多线程中线程体(run方法)中的死循环，可以保证线程一直运行，如果不循环线程，则运行一次就停止了。在上面的例子中线程体运行死循环，可以保证线程一直运行，每次运行都休眠1s，然后唤醒，再然后把时间信息输出到控制台。所以，线程体死循环是保证子线程一直运行的前提。由于是子线程它不会堵塞主线程，就不会感觉到程序死掉了。但是需要注意的是有时我们确实执行一次线程体，就不需要循环了。

　程序运行后开始启动线程，线程启动后就计算逝去的时间，每过1s将结果输出到控制台。当输入1字符后线程停止，程序终止。如图所示。

Java中的实现线程体方式2

　　上面介绍继承Thread方式实现线程体，下面介绍另一种方式，这种方式是提供一个实现接口Runnable的类作为一个线程的目标对象，构造线程时有两个带有Runnable target参数的构造方法：

　　Thread(Runnable target);

　　Thread(Runnable target, String name)。

　　其中的target就是线程目标对象了，它是一个实现Runnable的类，在构造Thread类时候把目标对象(实现Runnable的类)传递给这个线程实例，由该目标对象(实现Runnable的类)提供线程体run()方法。这时候实现接口Runnable的类仍然可以继承其他父类。

请参看代码清单，这是一个Java AWT的窗体应用程序。

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class textThread2 extends Frame implements Runnable, ActionListener {

    public Label label;
    public Button button;
    public Thread ClockThread;
    public boolean isRunning;
    public int timer = 0;

    public textThread2() {
        button = new Button("停止计时器");
        label = new Label("计算器启动");
        button.addActionListener(this);
        setLayout(new BorderLayout());
        add(button, "North");
        add(label, "Center");
        setSize(320, 480);
        setVisible(true);

        // textThread2 textThread2 = new textThread2();
        ClockThread = new Thread(this);
        ClockThread.start();
        isRunning = true;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        isRunning = false;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
            while (isRunning) {
                Thread.currentThread().sleep(1000);
                timer++;
                label.setText("逝去了" + timer);
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        textThread2 textThread2 = new textThread2();
    }
}

其中关于Java AWT知识就不在这里介绍了，有兴趣的读者可以自己看看相关书籍。在本例中构建AWT窗体的应用程序方式是继承Frame类。采用第1种方式——继承方式实现线程体是不可以的，因为Java是单继承的，这个类不能既继承Frame又继承Thread。应该采用第2种方式——实现Runnable接口方式。Runnable接口也有一个run()方法，它是实现线程体方法，其代码处理与上一节是一样。需要注意的是，在第2种方法中，创建了一个Thread成员变量clockThread，才用构造方法new Thread(this)创建一个线程对象，其中创建线程使用的构造方法是Thread(Runnable target)，其中的this就是代表本实例，它是一个实现了Runnable接口的实现类。

程序运行结果如图所示，屏幕开始加载的时候线程启动开始计算时间，1s更新一次UI，当单击“结束计时”按钮时，停止计时。

Java中的实现线程体方式3

　　实现线程体方式3是实现线程体方式2的变种，本质上还是实现线程体方式2，但是在Android应用开发中经常采用第3种方式。下面我们看第3种方式的计时器代码清单.

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class TextThread3 extends Frame implements ActionListener {

    private Button button;
    private Label label;
    private Thread clockThread;
    private int timer = 0;
    private boolean isRunning = true;

    public TextThread3() {
        button = new Button("停止计时");
        label = new Label("计时器开始。。。");
        button.addActionListener(this);
        setLayout(new BorderLayout());
        add(button, "North");
        add(label, "Center");
        setSize(320, 480);
        setVisible(true);

        clockThread = new Thread(new Runnable() {

            @Override
            public void run() {
                while (isRunning) {
                    try {
                        Thread.currentThread().sleep(1000);
                        timer ++;
                        label.setText("逝去了："+timer);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        clockThread.start();
        isRunning = true;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        isRunning = false;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        TextThread3 thread3 = new TextThread3();
    }
}

与第2种方式比较，我们发现Frame类不再实现Runnable接口了，而是在实例化Thread类的时候，定义了一个实现Runnable接口的匿名内部类：

clockThread = new Thread(new Runnable() {

            @Override
            public void run() {
                while (isRunning) {
                    try {
                        Thread.currentThread().sleep(1000);
                        timer ++;
                        label.setText("逝去了："+timer);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

有关Java多线程的内容还有很多，例如线程优先级、线程同步等，由于这些内容与本书关系不是很紧密，所以不再介绍了，有关其他的线程知识可以参考Java方面的书籍。接下来介绍一下Android中的线程。

Android中的线程

　　在Android平台中多线程应用很广泛，在UI更新、游戏开发和耗时处理(网络通信等)等方面都需要多线程。Android线程涉及的技术有：Handler;Message;MessageQueue;Looper;HandlerThread。

　　Android线程应用中的问题与分析

　　为了介绍这些概念，我们把计时器的案例移植到Android系统上，按照在Frame方式修改之后的代码清单.

package com.example.testthread4;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.*;
import android.app.Activity;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;

public class MainActivity extends Activity {

    private Button mButton;
    private TextView mTextView;
    private boolean isRunning = true;
    private Thread mThread;
    private int timer = 0;
    //private Handler handler;

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

        mButton = (Button) findViewById(R.id.button1);
        mTextView = (TextView) findViewById(R.id.textView1);

        mButton.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // TODO Auto-generated method stub
                isRunning = false;
            }
        });
        /*handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                case 0:
                    mTextView.setText("逝去了:" + msg.obj);
                }
            }
        };*/
        mThread = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    while (isRunning) {
                        Thread.currentThread().sleep(1000);
                        timer++;
                        /*Message message = new Message();
                        message.obj = timer;
                        message.what = 0;
                        handler.sendMessage(message);*/
                        mTextView.setText("逝去了:"+timer);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        mThread.start();
    }
}

程序打包运行结果出现了异常，如图所示。

我们打开LogCat窗口，出错日志信息如图所示。

系统抛出的异常信息是“Only the original thread that created a view hierarchy can touch its views”，在Android中更新UI处理必须由创建它的线程更新，而不能在其他线程中更新。上面的错误原因就在于此。

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

　　由于labelTimer是一个UI控件，它是在主线程中创建的，但是它却在子线程中被更新了，更新操作在clockThread线程的run()方法中实现，代码如下：

mThread = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    while (isRunning) {
                        Thread.currentThread().sleep(1000);
                        timer++;
                        /*Message message = new Message();
                        message.obj = timer;
                        message.what = 0;
                        handler.sendMessage(message);*/
                        mTextView.setText("逝去了:"+timer);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

这样的处理违背了Android多线程编程规则，系统会抛出异常“Only the original thread that created a view hierarchy can touch its views”。

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

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

在Android中，线程有两个对象—消息(Message)和消息队列(MessageQueue)可以实现线程间的通信。下面再看看修改之后的代码清单.

package com.example.testthread4;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.*;
import android.app.Activity;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;

public class MainActivity extends Activity {

    private Button mButton;
    private TextView mTextView;
    private boolean isRunning = true;
    private Thread mThread;
    private int timer = 0;
    private Handler handler;

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

        mButton = (Button) findViewById(R.id.button1);
        mTextView = (TextView) findViewById(R.id.textView1);

        mButton.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // TODO Auto-generated method stub
                isRunning = false;
            }
        });
        handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                case 0:
                    mTextView.setText("逝去了:" + msg.obj);
                }
            }
        };
        mThread = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    while (isRunning) {
                        Thread.currentThread().sleep(1000);
                        timer++;
                        Message message = new Message();
                        message.obj = timer;
                        message.what = 0;
                        handler.sendMessage(message);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        mThread.start();
    }
}

有的时候为了将Android代码变得更加紧凑，把线程的创建和启动编写在一条语句中，如下面

        /*mThread = */new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    while (isRunning) {
                        Thread.currentThread().sleep(1000);
                        timer++;
                        Message message = new Message();
                        message.obj = timer;
                        message.what = 0;
                        handler.sendMessage(message);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }).start();