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 {
@Override
public 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;
@Override
public 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
返回结果并可能引发异常的任务。 实现者定义一个没有参数的单一方法，称为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 {
//2.实现call方法，将此线程需要执行的操作声明在call方法中
@Override
public 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 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 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异 常。
• 只计算一次