Android 中多线程的简单使用

一、多线程的实现

1.最简单的启动一下新线程

private void startNewThread(){
new Thread(){
@Override
public void run() {
//耗时操作
}
}.start();
}

或者：

private void startNewThread(){
new Thread(new Runnable() {
@Override
public void run() {
//耗时操作
}
}){}.start();
}

实际上查看源码可以知道:Thread也是一个Runable,它实现Runable接口，在Thread类中有一个Runable类型的target字段，代表这个要执行在这个子线程中的任务。

Thread中默认的run方法源码为:

@Override
public void run() {
if (target != null) {
target.run();
}
}

2.线程中waite、sleep、join、yield方法

wait(): 当一个线程执行到wait() 方法时，它就进入到了一个和该对象相关的等待池中，同时失去（释放)了对象的机锁，使得其他线程可以访问。用户可以使用notify,notifyAll或者指定睡眠时间来唤醒当前等待池中的线程。

sleep(): 该方法时Thread的静态函数，作用是使调用线程进入睡眠状态。因为sleep()是Thread()类的static 方法。因此他不能改变对象的机锁。所以当一个synchronized快中调用sleep（）方法时，线程虽然睡眠了，但是对象的机锁并没有被释放，其他线程无法访问到这个对象。(即使睡着也持有这对象锁)

join(): 等待目标线程执行完成之后，再继续执行。

yield(): 线程礼让，目标线程由运行状态转换为就绪状态，也就是让出执行权限，让其他线程得以优先执行，但其他线程是否优先执行时未知的。

简单示例:

wait()示例：

public class MyClass {
//    用于等待、唤醒的对象
private static Object sLockObject = new Object();

static void waitAndNotityAll() {
System.out.println("主线程中执行");
//        创建并启动子线程
Thread thread = new WaiteThread();
thread.start();
long startTime = System.currentTimeMillis();
try {
synchronized (sLockObject) {
System.out.println("主线程等待");
sLockObject.wait();
}
} catch (Exception e) {

}

long timeMs = System.currentTimeMillis() - startTime;
System.out.println("主线程继续--等待耗时: " + timeMs + " ms");
}

//    等待线程
static class WaiteThread extends Thread {
@Override
public void run() {
try {
synchronized (sLockObject) {
Thread.sleep(3000);
sLockObject.notifyAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args){
waitAndNotityAll();
}
}
执行结果:
主线程中执行
主线程等待
主线程继续--等待耗时: 3001 ms

join() 示例:

public class JoinTest {
static void joinDemo(){
Worker worker1 = new Worker("worker-1");
Worker worker2 = new Worker("worker-2");
worker1.start();
System.out.println("启动线程1");

try {
//            调用worker1的join函数,主线程会阻塞直到worker1执行完成
worker1.join();
System.out.println("启动线程2");
worker2.start();
worker2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("主线程继续执行");
}

static class Worker extends Thread{

public Worker(String name){
super(name);
}

@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("work in " +getName());
}
}

public static void main(String[] args){
joinDemo();
}
}

执行结果:
启动线程1
work in worker-1
启动线程2
work in worker-2
主线程继续执行

yield()示例:

public class YieldTest {

public static final int MAX = 5;

static class YieldThread extends Thread {
public YieldThread(String name) {
super(name);
}

public synchronized void run() {
for (int i = 0; i < MAX; i++) {
System.out.printf("%s priority: [%d]------> %d\n", this.getName(), this.getPriority(), i);
//                当i==2 是,调用当前线程的yield函数。
if (i == 2) {
Thread.yield();
}
}
}
}

static void yieldDemo() {
YieldThread t1 = new YieldThread("thread-1");
YieldThread t2 = new YieldThread("thread-2");
t1.start();
t2.start();
}

public static void main(String[] args) {
yieldDemo();
}

}
可能没有效果

3、与多线程相关的方法—–Callable、Future、FutureTask

Callable 与Runable的功能大致相似，不同的是Callable是一个泛型接口，它有一个泛型的参数V ，该接口有一个返回值(类型为V)的call 函数而Runable 的run()函数不能将结果返回给客户程序。Callable的声明如下:

public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}

而 Future为线程池制定了一个可管理的任务标准，它提供了对Runable或者Callable任务的执行结果进行取消，查询是否完成、获取结果、设置结果操作、分别对应cancel、isDone、get、set函数。get方法会阻塞，直到任务返回结果。future声明如下:

public interface Future<V> {
//取消任务
boolean cancel(boolean mayInterruptIfRunning);

//任务是否已经取消
boolean isCancelled();

//任务是否已经完成
boolean isDone();

//获取结果，如果任务未完成，则等待，直到完成，因此该函数会阻塞
V get() throws InterruptedException, ExecutionException;

//获取结果，如果还未完成那么等待，直达timeout 或者返回结果，该函数会阻塞
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}

Future 只是定义了一些规范的接口，而FutureTask则是它的实现类。FutureTask实现了RunableFuture< V > 而RunableFuture又 继承自 Runable,和Ruture< V > 这两个接口，因此FutureTask具备了他们的能力。FutureTask代码如下:

public class FutureTask<V> implements RunnableFuture<V> {
.......
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
}

FutureTask会像Thread包装Runable 那样包装 Callable,或者Runable

参考FutureTask的构造方法:

public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;       // ensure visibility of callable
}

public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW;       // ensure visibility of callable
}

其中第二个构造方法，调用Executors.callable（）函数将一个runnable转换成一个实现Callable接口的类。参考代码:

public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
/**
* A callable that runs given task and returns given result
*/
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}

由于FutureTask实现了Runable ,因此，它既可以通过Thread包装来直接执行，也可以提交给ExcuteService来执行。并且还可以直接通过get()函数获取执行结果，该函数会阻塞，知道结果返回。因此FutureTask既是Future,Runable，又包装了Callable，(如果Runnable最终也会被转换为Callable),他是这两者的合体。

代码示例:

public class FutureDemo {
//    线程池
static ExecutorService mExecutor  = Executors.newSingleThreadExecutor();

public static void main(String[] args){
try {
futureWithRunable();
futureWithCallable();
futureTask();
}catch (Exception e){

}
}

private static void futureTask() throws ExecutionException, InterruptedException {
FutureTask<Integer> futureTask  =new FutureTask<Integer>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
return fibc(20);
}
}) ;
//提交futureTask
mExecutor.submit(futureTask);
System.out.println("future result from futureTask : "+futureTask.get());
}

private static void futureWithCallable() throws ExecutionException, InterruptedException {
final Future<Integer> result2 = mExecutor.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
return fibc(20);
}
}) ;
System.out.println("future reuslt from callable: "+result2.get()) ;
}

private static void futureWithRunable() throws ExecutionException, InterruptedException {
//        提交runable,没有返回值，future没有数据
Future<?> result = mExecutor.submit(new Runnable() {
@Override
public void run() {
fibc(20);
}
});

System.out.println("future result from runable : "+result.get());
}

private static int fibc(int num){
if(num==0){
return 0;
}
if(num==1){
return 1 ;
}
return fibc(num-1) +fibc(num-2);
}
}

二、线程池

线程池的优点:

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

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

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

线程池都实现了ExecuteService接口，该接口定义了线程池需要实现的接口。如submit、excute、shutdow、等方法

它的实现有 ThreadPoolExecutor和ScheduledThreadPoolExecutor。

1、启动指定数量的线程——ThreadPoolExecutor

ThreadPoolExecutor的构造方法如下:

public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}

corePoolSize: 线程池所保存的核心线程数，线程池启动后默认是空的，只有任务来临时才会创建线程以处理请求。prestartCoreThreads方法可以在线程池启动后即启动所有核心线程一等待任务。

maximumPoolSize: 线程池允许创建的最大线程数，当workQueue使用无界队列时(如LinkedBlockingQueue),则此参数无效。它与corePoolSize的作用是调整“线程池中实际运行的线程数量” 。例如，当新任务提交给线程池时，如果线程池中的运行线程数量小于corePoolSize，则创建新线程来处理请求，如果此时，线程池中的运行线程数量大于corePoolSize，但小于maximumPoolSize，则仅当阻塞队列满时才创建新线程，如果设置的corePoolSize 和maximumPoolSize 相同，则创建了固定大小的线程池，如果将maxiumPoolSize设置为基本的无界值(如： Integer.MAX_VALUE),则允许线程池适应任意数量的并发任务。

keepAliveTime: 当前线程池线程总数大于核心线程数时，终止多余的空闲线程的时间。

Unit: keepAliveTime参数的时间单位，可选值有毫秒，秒，分等。

workerQueue： 任务队列，如果当前线程池，达到核心线程数corePoolSize，且当前所有线程都处于活动状态时，则将新加入的任务放到此队列中。

threadFactory: 线程工厂，让用户可以定制线程的创建过程，通常不需要设置。

Handle ： 决绝策略，当线程池与workQueue队列都满了的情况下，对新任务采取的处理策略。