android的多线程代码,Android 多线程编程初探(示例代码)

Android 中的多线程其实就是 JavaSE 中的多线程，只是为了方便使用，android 封装了一些类，如 AsyncTask、HandlerThread 等，在日常的开发过程中，我们往往需要去执行一些耗时的操作，例如发起网络请求，考虑到网速等其他外在的因素，服务器可能不会立刻响应我们的请求，如果不将这条操作放到子线程中去执行，就会造成主线程被阻塞，今天我们就从多线程的基础来一起探讨

一、线程的基本用法

对于 Andorid 多线程来说我们最新接触到的就是 Thread 和 Runnable 通常我们如下来启动一个新的线程

1)继承自 Thread 来创建子线程

定义一个线程只需要新建一个类继承自 Thread，然后重写父类的 run 方法即可

/**

* 继承 Thread 创建子线程

*/

class MyThread extends Thread {

@Override

public void run() {

//处理具体的逻辑

}

}

那么如何启动这个线程呢？只需要 new 出 MyThread 的实例，然后调用它的 start() 方法，这样 run() 方法中的代码就会运行在子线程，如下：

new MyThread().start();

2)实现 Runnable 接口来创建子线程

继承方式耦合性高，更多时候我们会选择实现 Runnable 接口的方式来实现一个子线程，如下：

/**

* 实现 Runnable 接口创建子线程

*/

class MyThread implements Runnable {

@Override

public void run() {

//处理具体的逻辑

}

}

如果使用这种写法，启动线程的方法也需要相应的改变，如下：

MyThread myThread = new MyThread();

new Thread(myThread).start();

Thread 构造函数接受一个 Runnable 参数，我们 new 出的 MyThread 正是一个实现了 Runnable 接口的对象，所以可以直接将它传入到 Thread 的构造函数里，接着就和上面的一样了，调用 Thread 的 start() 方法，run() 方法中的代码就会在子线程当中运行了

3)直接使用匿名类来创建子线程

new Thread(new Runnable() {

@Override

public void run() {

//处理具体的逻辑

}

}).start();

如果你不想再定义一个类去实现 Runnable 接口，也可以使用如上匿名类的方式来实现，这种实现方式也是我们最常用到的

以上这些就是我们来创建子线程时使用的不方式，基本和 Java 中一样

4)Thread 和 Runnable 的区别

实际上 Thread 也是一个 Runnable，它实现了 Runnable 接口，在Thread类中有一个 Runnable 类型的 target字段，代表要被执行在这个子线程中的任务，代码如下：

Thread 部分源码：

public class Thread implements Runnable {

/* What will be run. */

private Runnable target;

/* The group of this thread */

private ThreadGroup group;

private String name;

/*

* The requested stack size for this thread, or 0 if the creator did

* not specify a stack size.  It is up to the VM to do whatever it

* likes with this number; some VMs will ignore it.

*/

private long stackSize;

/**

* 初始化 Thread 并且将Thread 添加到 ThreadGroup 中

*

* @param g

* @param target

* @param name

* @param stackSize

*/

private void init(ThreadGroup g, Runnable target, String name, long stackSize) {

java.lang.Thread parent = currentThread();

//group 参数为空，则获取当前线程的才线程组

if (g == null) {

g = parent.getThreadGroup();

}

this.group = g;

this.name = name;

//设置 target

this.target = target;

/* Stash the specified stack size in case the VM cares */

this.stackSize = stackSize;

}

public Thread() {

init(null, null, null, 0);

}

public Thread(Runnable target) {

init(null, target, null, 0);

}

public Thread(ThreadGroup group, Runnable target) {

init(group, target, null, 0);

}

public Thread(Runnable target, String name) {

init(null, target, name, 0);

}

public Thread(ThreadGroup group, Runnable target, String name) {

init(group, target, name, 0);

}

public Thread(ThreadGroup group, Runnable target, String name,

long stackSize) {

init(group, target, name, stackSize);

}

/**

* 启动一个新的线程，如果target 不为空则执行 target 的 run 函数

* 否者执行当前对象的run()方法

*/

public synchronized void start() {

//调用 nativeCreate 启动新线程

nativeCreate(this, stackSize, daemon);

started = true;

}

@Override

public void run() {

if (target != null) {

target.run();

}

}

}

上面是 Thread 的部分源码，我们看到其实 Thread 也实现了 Runnable 接口，最终被线程执行的是 Runnable，而非 Thread，Thread 只是对 Runnable 的包装，并且通过一些状态对 Thread 进行管理与调度，Runnable 定义了可执行的任务它只有一个无返回值的 run() 函数，如下：

public interface Runnable {

/**

* When an object implementing interface Runnable is used

* to create a thread, starting the thread causes the object‘s

* run method to be called in that separately executing

* thread.

* 

* The general contract of the method run is that it may

* take any action whatsoever.

*

* @see java.lang.Thread#run()

*/

public abstract void run();

}

当启动一个线程时，如果 Thread 的 Target 不为空时，则会在子线程中执行这个 target 的 run() 函数，否则虚拟机就会执行该线程自身的 run() 函数

二、线程的 wait、sleep、join、yield

Thread 的基本用法相对来说比较简单，通常就是复写 run() 函数，然后调用线程的 start() 方法启动线程，接下来我们来看看 wait、sleep、join、yield 的区别

1)wait

当一个线程执行到 wait() 方法时，它就进入到一个和该对象相关的等待池中，同时释放对象的机锁，使得其它线程可以访问，用户可以使用 notify、nitifyAll 或者指定睡眠时间来唤醒当前等待池中的线程，注意：wait()、notify()、notifyAll() 必须放在 Synchronized 块中，否则会抛出异常

2)sleep

该函数是 Thread 的静态函数，作用是使调用线程进入睡眠状态，因为 sleep() 是 Thread 类的静态方法，因此它不能改变对象锁，所以当在一个 Synchronized 块中调用 sleep() 方法时，线程虽然休眠了，但是对象的锁并没有被释放，其它线程无法访问这个对象，即使睡眠也持有对象的锁

3)join

等待目标线程执行完之后再继续执行

4)yield

线程礼让，目标线程由运行状态转换为就绪状态，也就是让出执行权限，让其它线程可以优先执行，但其他线程能否优先执行未知

三、线程池

当我们需要频繁的创建多个线程进行耗时操作时，每次都经过 new Thread 实现并不是一种好的方式，每次 new Thread 新建和销毁对象的性能较差，线程缺乏统一管理，可能无限制新建线程，相互之间竞争，可能占用过多系统资源导致死锁，并且缺乏定时执行，定期执行，线程中断等功能，Java 提供了 4 种线程池，它能够有效的管理，调度线程，避免过多的浪费系统资源，它的优点如下：

1)重用存在的线程，减少对象创建，销毁的开销

2)可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多的资源竞争，避免堵塞

3)提供定时执行、定期执行、单线程、并发数控制等功能

简单来说，线程池原理简单的解释就是会创建多个线程并进行管理，提交给线程的任务会被线程池指派给其中的线程进行执行，通过线程池的统一调度、管理使得多线程使用更加简单、高效，如下图：

线程池都实现了 ExecutorService 接口，改接口定义了线程池需要实现的接口，它的实现有  ThreadPoolExecutor 和 ScheduledThreadPoolExecutor，ThreadPoolExecutor 也就是我们运用最多的线程池实现，ScheduledThreadPoolExecutor 用于周期性执行任务，通常我们都不会直接通过 new 的形式来创建线程池，由于创建参数过程相对复杂一些，因此 JDK 给我们提供了一个 Executor 工厂类来简化这个过程

线程池的使用准则：

1)不要对那些同步等待的其他任务结果的任务排队，这可能会导致死锁，在死锁中所有所有线程都被一些任务所占用，这些任务依次等待排队任务的结果，而这些任务又无法执行，因为所有的线程处于忙碌状态

2)理解任务，要有效的调整线程池的大小，你需要理解正在排队的任务以及它们正在做什么

3)调整线程池的大小基本上就是避免两类错误，线程太少或线程太多，幸运的是对于大多数应用程序来说，太多和太少之间的余地相当宽

今天介绍的基本都是一些理论的东西，有的看起来可能没劲，大家就当了解一下吧，又到周五了，祝大家周末愉快

参考：郭神第一行代码，Android 进阶