Android初学之Runnable和Thread

Runnable代表了一条能被执行的命令，经常用在不同的线程里去执行一段代码的接口。其中只有一个方法：void run()，该方法用于执行相关的业务代码，当实现了Runnable接口的类创建了一个线程并启动了该线程（即使用了void start()方法）时，会调用run方法。

Runnable的使用：

1、 实现Runables接口外部类：

public class MainActivity extends AppCompatActivity {

public class MyThread implements Runnable{

@Override
public void run() {
for(int i=0;i<10;i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("这是一个实现了Runnable的线程");
}
}
}
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

@Override
protected void onResume() {
super.onResume();
MyThread myThread = new MyThread();
//        Thread thread = new Thread(myThread);
//        thread.start();
myThread.run();
for(int i=0;i<10;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("这是主线程");
}
}
}

很容易能够看出上述代码的缺点：MyThread中的方法只是用了一次，但是却以一个外部类的形式描述，显然是不合理的，因此可以在匿名内部类表述出来。匿名内部类一般用于只执行一次的情况下使用，减少代码量，而外部类主要适用于需要多次重复使用的情况。

2、匿名内部类

ackage com.zhouyou.robocademoproj;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

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

@Override
protected void onResume() {
super.onResume();
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<8;i++){
System.out.println("这是匿名内部类的使用");
}
}
};
Thread thread = new Thread(runnable);
thread.start();

for(int i = 0;i<8;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("这是主线程的使用");
}
}
}

3、Runnable的一些理解：

我们暂且抛开匿名内部类和外部类的区别，看一下上述代码的输出结果发现，两个线程的输出是交替出现的，且两个线程id是不同的。



所以，我们就好理解为什么API中说它是运行在一个不同的线程里了。

4、 如果直接调用Runnable的run方法会出现什么情况呢？

package com.zhouyou.robocademoproj;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

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

@Override
protected void onResume() {
super.onResume();
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<8;i++){
System.out.println("这是匿名内部类的使用");
}
}
};
runnable.run();
//直接调用run方法，不使用Thread的start
//        Thread thread = new Thread(runnable);
//        thread.start();

for(int i = 0;i<8;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("这是主线程的使用");
}
}
}

运行的输出结果如下：



因为次数只有10次，为保证正确性，我实验了n次，发现都是上述结果。

上图中，线程id是一样的，也就是说根本没有新开一个线程去运行Runnable相关的代码，而是直接在主线程运行的，说明了一点：直接调用run方法，不经过start并不能实现多线程，也就是像Runnable源码中解释的那样，Runnable只是一个代表了一条能被执行的命令，经常用在不同的线程里去执行一段代码的接口，注意它是用在线程里，而不是自身就能直接多线程。

我们再看看Thread中的start方法：

/**
* Starts the new Thread of execution. The <code>run()</code> method of
* the receiver will be called by the receiver Thread itself (and not the
* Thread calling <code>start()</code>).
*
* @throws IllegalThreadStateException - if this thread has already started.
* @see Thread#run
*/
public synchronized void start() {
checkNotStarted();

hasBeenStarted = true;

nativeCreate(this, stackSize, daemon);
}

start方法完成了实现多线程的初始化操作，run方法中完成了业务操作（一般是编程者自己写的业务实现代码）。至于如何实现的，则不是我们需要关心的。

Thread是一个执行并发的单元，他有自己的方法调用栈，参数栈和本地变量的栈。每一个应用开始后，在主线程组中至少有一个运行着的主线程。Thread本质上来说他是一个实现了Runnable接口的类，他在Runnable的基础上添加了一些能够保证多线程运行的机制。一般来说有两种方法在新线程中执行业务代码：

1、继承了Thread并重写了run方法的Thread子类。

2、将一个实现了Runnable接口的实例作为Thread的构造参数（Runnable中的demo就是这么做的）。

除了大量的构造函数，还有一些基本成员属性，比如name、priority、stackSize、packState等，这些属性都是为了更好的实现多线程。