线程的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
网友评论