Android多线程（一）——线程的创建方式

线程的3种创建方式：

1. 继承Thread类创建线程类

2. 实现Runnable接口创建线程类

3. 实现Callable接口和使用Future创建线程

一. 继承Thread类创建线程类

通过继承Thread类来创建并启动多线程的步骤如下。

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务。run()方法也叫线程执行体。
创建Thread子类的实例，即创建了线程对象。
调用线程对象的start()方法来启动该线程。

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i=0;i<6;i++){
            try {
                //当继承Thread类时，直接使用this即可获取当前线程
                Log.d("MyThread:",getName()+" i:"+i);
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

通过setName(String name)设置线程名，通过getName()返回线程名。默认情况下，主线程的名字为main，用户启动的多个线程的名字依次为Thread-0，Thread-1，......Thread-n等。
Thread.currentThread()获取当前正在执行的线程对象
使用继承Thread类的方法来创建线程类时，多个线程之间无法共享线程之间的实例变量

二. 实现Runnable创建线程类

实现Runnable接口来创建并启动的多线程的步骤如下

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体是该线程执行体。
创建Runnable的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

public class MyRunnable implements Runnable {
    private int i;
    @Override
    public void run() {
        for (;i<6;i++){
            Log.d("MyRunnable:",Thread.currentThread().getName()+" i:"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//使用
    private void runnable(){
        Runnable myRunnable=new MyRunnable();
        new Thread(myRunnable,"MyRunnable1").start();
        new Thread(myRunnable,"MyRunnable2").start();
    }

运行打印结果
2020-05-03 23:48:35.089 5889-5917/priv.hsj.thread D/MyRunnable:: MyRunnable2 i:0
2020-05-03 23:48:35.089 5889-5916/priv.hsj.thread D/MyRunnable:: MyRunnable1 i:0
2020-05-03 23:48:36.092 5889-5916/priv.hsj.thread D/MyRunnable:: MyRunnable1 i:2
2020-05-03 23:48:36.092 5889-5917/priv.hsj.thread D/MyRunnable:: MyRunnable2 i:2
2020-05-03 23:48:37.094 5889-5916/priv.hsj.thread D/MyRunnable:: MyRunnable1 i:4
2020-05-03 23:48:37.094 5889-5917/priv.hsj.thread D/MyRunnable:: MyRunnable2 i:4
2020-05-03 23:48:38.097 5889-5916/priv.hsj.thread D/MyRunnable:: MyRunnable1 i:5

我们可以看到，线程MyRunnable1和MyRunnable2共享了同一个线程类myRunnable，并且还共享同一个线程类的实例变量

三. 使用Callable和Future创建线程

知识储备：FutureTask类和Future接口以及Callable接口

1. Future接口

前言：不管是继承Thread还是实现Runnable，都没法获取到之前的执行结果。通过实现Callable接口并用Future来接收多线程的执行结果。
Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future接口方法解析

V get() ：获取异步执行的结果，如果没有结果可用，此方法会阻塞直到异步计算完成。
V get(Long timeout , TimeUnit unit) ：获取异步执行结果，如果没有结果可用，此方法会阻塞，但是会有时间限制，如果阻塞时间超过设定的timeout时间，该方法将抛出异常。
boolean isDone() ：如果任务执行结束，无论是正常结束或是中途取消还是发生异常，都返回true。
boolean isCanceller() ：如果任务完成前被取消，则返回true。
boolean cancel(boolean mayInterruptRunning) ：如果任务还没开始，执行cancel(...)方法将返回false；如果任务已经启动，执行cancel(true)方法将以中断执行此任务线程的方式来试图停止任务，如果停止成功，返回true；当任务已经启动，执行cancel(false)方法将不会对正在执行的任务线程产生影响(让线程正常执行到完成)，此时返回false；当任务已经完成，执行cancel(...)方法将返回false。mayInterruptRunning参数表示是否中断执行中的线程。
通过方法分析我们也知道实际上Future提供了3种功能：（1）能够中断执行中的任务（2）判断任务是否执行完成（3）获取任务执行完成后额结果。

2. FutureTask类

FutureTask实现了RunnableFuture接口，RunnableFuture接口继承了Runnable接口和Future接口，即FutureTask实现了Future接口，也就拥有了可以获取异步任务处理的执行结果的能力。

public class FutureTask<V> implements RunnableFuture<V> {
public FutureTask(Callable<V> callable) {
        ...
    }
public FutureTask(Runnable runnable, V result) {
        ...
    }
....
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

3. Callable接口

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

创建并启动有返回值的线程的步骤如下：

创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值，再创建Callable实现类的实例。
使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
两种方式创建新线程并启动
3.1 使用Future对象作为Thread对象的target创建并启动新线程。
3.2 使用Future对象作为线程池ExecutorService#submit对象创建并启动新线程。
调用FutureTask对象的get()方法来获得子线程执行后的返回值。

public class MyCallable implements Callable {
    private int i;
    @Override
    public Object call() throws Exception {
        for (;i<6;i++){
            Log.d("MyCallable:",Thread.currentThread().getName()+" i:"+i);
            Thread.sleep(1000);
        }
        return "Callable耗时操作完成了已经";
    }
}

//使用
    private void callable(){

        Callable callable=new MyCallable();

        FutureTask futureTask=new FutureTask(callable);
        FutureTask futureTask1=new FutureTask(callable);
        //方法一：用Thread
//        Thread thread=new Thread(futureTask);
//        thread.start();
        //方法二：用线程池
        ExecutorService executorService= Executors.newCachedThreadPool();
        executorService.submit(futureTask);
        executorService.submit(futureTask1);

        try {
            String a= (String) futureTask.get();
            Log.d(TAG,a);
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       
    }

运行日志打印
2020-05-04 00:00:37.350 6292-6356/priv.hsj.thread D/MyCallable:: pool-1-thread-1 i:0
2020-05-04 00:00:37.351 6292-6357/priv.hsj.thread D/MyCallable:: pool-1-thread-2 i:0
2020-05-04 00:00:38.353 6292-6356/priv.hsj.thread D/MyCallable:: pool-1-thread-1 i:1
2020-05-04 00:00:38.356 6292-6357/priv.hsj.thread D/MyCallable:: pool-1-thread-2 i:2
2020-05-04 00:00:39.356 6292-6356/priv.hsj.thread D/MyCallable:: pool-1-thread-1 i:3
2020-05-04 00:00:39.359 6292-6357/priv.hsj.thread D/MyCallable:: pool-1-thread-2 i:4
2020-05-04 00:00:40.359 6292-6357/priv.hsj.thread D/MyCallable:: pool-1-thread-2 i:5
2020-05-04 00:00:40.361 6292-6292/priv.hsj.thread D/MainActivity-->: Callable耗时操作完成了已经

我们也能看到Callable线程类也是可以共用，其线程类里的变量也是共用的

四. 总结

采用实现Runnable，Callable接口的方式创建多线程的优缺点

实现Runnable接口与实现Callable接口的方式基本相同，只是Callable接口定义的方法有返回值，可以抛出异常。
线程类只是实现了Runnable接口和Callable接口，还可以继承其他类。
多个线程可以共享同一个Runnable或Callable对象，非常适合多个线程来处理同一份资源的情况。
如果需要使用当前线程，则必须使用Thread.currentThread()方法;

采用Thread类的方式创建多线程的优缺点

线程类已经继承了Thread类，不能再继承其他父类。
编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this即可。

平时推荐采用实现Runnable接口或者Callable接口的方式来创建多线程。

多线程卖票：https://blog.csdn.net/weixin_43570367/article/details/102787154?utm_source=app