Java线程的创建方式

文章目录

创建线程的几种方法：
- ①继承Thread类
- ②实现Rullable接口
- ③实现Callable接口
- - Callable接口
  - Future 接口
  - FutureTask类
- ④使用线程池
- Runable和Callable的区别：
- 小结(重点)

创建线程的几种方法：

继承Thread方法
实现Runable接口
实现Callable接口
使用线程池

①继承Thread类

Thread类位于java.long包下。
步骤：

自定义线程类继承Thread类
重写run()方法，编写线程执行体（当成main()方法用）
创建线程对象，调用start()方法启动线程

常用方法：

start()启动当前线程；调用当前线程的run()方法
run()：通常需要重写Thread类中的此方法，将创建线程需要执行的操作声明在此方法中（当做main()使用）
currentThread()：静态方法，返回执行当前代码的线程
getName()：获取当前线程的名字
setName(String name)：设置当前线程的名字
yield()：释放当前CPU的执行权（但也有可能下一刻的执行权又回到了当前线程，主控权还是在CPU手上）
join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完之后，线程a在结束阻塞状态
stop()：当执行此方法时，强制结束当前线程（已停用）
sleep(int millitime)：让当前线程“睡眠”指定的millitime毫秒。在指定的- millitime毫秒时间内，当前进程是阻塞状态
isAlive()：判断当前线程是否存活（线程执行完之前都是存活的）

    public class MyThread extends Thread {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println("线程"+Thread.currentThread().getName() + ":遍历到 " + i);}}public static void main(String[] args) {MyThread mThread1=new MyThread();mThread1.setName("AA");mThread1.start();}}

注意的问题

start()方法的作用：通过调用自己写的线程类对象的start()方法，来启动该线程，并调用该线程的run()方法
不能通过直接调用run()方法的方式启动线程
不可以让已经start()的线程再次star()来同时跑两个线程。可以通过新建一个该线程类的对象，然后在对新建的对象start()

我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？？？
这是一个经典的Java多线程面试题，会被经常问道！！！

new一个Thread，线程进入了新建状态(new),调用start()方法，会启动一个线程并使线程进入就绪状态，当分配到时间片之后就可以运行了(万事俱备，只欠CPU)，start()会执行线程的相应准备工作，然后自动执行run()方法的内容，这是真正的多线程工作，但是，直接调用run()方法的内容，Java会把run()方法当成一个main线程下的普通方法执行，并不会在某个线程中执行它，所以这并不是多线程工作。

总结：调用 start() 方法方可启动线程并使线程进入就绪状态，直接执行 run() 方法的话不会以多线程的方式执行。

②实现Rullable接口

@FunctionalInterface
public interface Runnable
Runnable接口应由任何类实现，其实例将由线程执行。该类必须定义一个无参数的方法，称为run 。
该接口旨在为希望在活动时执行代码的对象提供一个通用协议。例如， Runnable由Thread类Thread 。
活跃的只是意味着一个线程已经启动，还没有被停止。

另外， Runnable提供了一个类被激活而不是Thread Thread类化的Thread 。
一个实现类Runnable可以在不继承运行Thread实例化一个Thread实例，并在传递本身作为目标。在大多数情况下，
Runnable接口应使用，如果你只打算重写run()方法并没有其他Thread方法。
这是重要的，因为类不应该被子类化，除非程序员打算修改或增强类的基本行为。

Ruallable接口只实现了run()方法

创建步骤

创建一个实现了Runnable接口的类
实现类去实现Runnable接口中的抽象方法：run()
创建实现类的对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
通过Thread类的对象调用start()
这里的start()首先启动了当前的线程，然后调用了Runnable类型的target的run()

public class MyThread implements Runnable {public  static int count = 20;@Overridepublic void run() {synchronized (this) {while (count > 0) {try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "-当前剩余票数:" + count--);}}}public static void main(String[] args) {MyThread Thread1 = new MyThread();Thread mThread1 = new Thread(Thread1, "线程1");Thread mThread2 = new Thread(Thread1, "线程2");mThread1.start();mThread2.start();}
}

优点：

实现Runnable接口的方式没有类的单继承性的局限性（一个类只能继承一个父类，继承了Thread类就不能在继承其他类了）
实现Runnable接口的方式更适合来处理多个线程之间有共享数据的情况

③实现Callable接口

public interface Callable<V>
返回结果并可能引发异常的任务。实现者定义一个没有参数的单一方法，称为call 。
Callable接口类似于Runnable ，因为它们都是为其实例可能由另一个线程执行的类设计的。然而，
Runnable不返回结果，也不能抛出被检查的异常。

Callable接口

现在我们学习的是创建线程的第三种方案—Callable 接口
Callable接口只实现了call方法：
创建步骤：

创建一个实现Callable的实现类
重写call方法，将此线程需要执行的操作声明在call方法中
创建Callable接口实现类的对象
将此Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法
get方法的返回值为FutureTask构造器参数Callable实现类重写的call方法的返回值。

Callable 接口的特点如下(重点)

• 为了实现 Runnable，需要实现不返回任何内容的 run（）方法，而对于Callable，需要实现在完成时返回结果的 call（）方法。

• call（）方法可以引发异常，而 run（）则不能。

• 为实现 Callable 而必须重写 call 方法

• 不能直接替换 runnable,因为 Thread 类的构造方法根本没有 Callable

Future 接口

当 call（）方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用 Future 对象。将 Future 视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦Callable 返回）。Future 基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。
要实现此接口，必须重写 5 种方法，如下:

boolean cancel(boolean mayInterruptIfRunning)
尝试取消执行此任务。如果任务已经完成，已经被取消或由于某种其他原因而无法取消，则此尝试将失败。如果成功，并且当cancel时此任务尚未启动，则此任务不应运行。如果任务已经开始，那么mayInterruptIfRunning参数确定是否执行此任务的线程应该以试图停止任务被中断。
此方法返回后，后续调用isDone()将始终返回true 。随后电话isCancelled()总是返回true如果此方法返回true 。

boolean isCancelled()
如果此任务在正常完成之前被取消，则返回 true 。

boolean isDone()
返回true如果任务已完成。完成可能是由于正常终止，异常或取消 - 在所有这些情况下，此方法将返回true 。

V get()
throws InterruptedException,
ExecutionException
等待计算完成，然后检索其结果。

V get(long timeout,
TimeUnit unit)
throws InterruptedException,
ExecutionException,
TimeoutException
如果需要等待最多在给定的时间计算完成，然后检索其结果（如果可用）。

FutureTask类

FutureTask可用于包装Callable或Runnable对象。因为FutureTask实现Runnable ，一个FutureTask可以提交到一个Executor执行。

构造方法：

public FutureTask(Callable callable)
创建一个 FutureTask ，它将在运行时执行给定的 Callable 。
public FutureTask(Runnable runnable,
V result)
创建一个 FutureTask ，将在运行时执行给定的 Runnable ，并安排 get将在成功完成后返回给定的结果。

主要方法：

所以使用Collable接口创建线程时可使用FutureTask类。

//1.创建实体类实现Callable接口
class NumThread implements Callable<Integer> {//2.实现call方法，将此线程需要执行的操作声明在call方法中@Overridepublic Integer call() throws Exception {System.out.println(Thread.currentThread().getName());return 1024;}
}public class Demo2 {public static void main(String[] args) {//3.创建Callable接口实现类的对象Callable callable = new NumThread();//4.将此Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象FutureTask<Integer> futureTask = new FutureTask<>(callable);//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法new Thread(futureTask, "BB").start();//6.返回true如果任务已完成。 完成可能是由于正常终止，异常或取消 - 在所有这些情况下，此方法将返回true 。while (!futureTask.isDone()) {System.out.println(" wait,,,,,.");}try {//7.get方法的返回值为FutureTask构造器参数Callable实现类重写的call方法的返回值。System.out.println(futureTask.get());} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "BB结束了");}}

④使用线程池

待续… …

Runable和Callable的区别：

是否有返回值：
- Runable没有返回值
- Callable有返回值
是否抛出异常
- Runable不能抛异常
- Callable会抛异常
实现的方法名称不同
- Runable实现的是run()方法
- Callable实现的是call()方法
创建多线程需要Runable，想要返回结果，需要Callable/Future

小结(重点)

• 在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成, 当主线程将来需要时，就可以通过 Future对象获得后台作业的计算结果或者执行状态• 一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果

• 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。

• 只计算一次