Java线程的创建方式

文章目录

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

创建线程的几种方法：

1. 继承Thread方法
2. 实现Runable接口
3. 实现Callable接口
4. 使用线程池

①继承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的区别：

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

小结(重点)

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

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

• 只计算一次