实现线程的方式

一、实现线程的方式

1.实现 Runnable 接口

package com.moon.erupt.impl;


/**
 * @ClassName RunnableThread
 * @Author zhangqing
 * @Date 2022/11/21
 * @Description 实现Runnable
 * @Version 1.0
 */
public class RunnableThread  implements  Runnable{
    @Override
    public void run() {
        System.out.println("实现了Runnable，创建线程");
    }
}

第 1 种方式是通过实现 Runnable 接口实现多线程，如代码所示，首先通过 RunnableThread 类实现
Runnable 接口，然后重写 run() 方法，之后只需要把这个实现了 run() 方法的实例传到 Thread 类中就
可以实现多线程。

2.继承 Thread 类

package com.moon.erupt.impl;

/**
 * @ClassName ExtendsThread
 * @Author zhangqing
 * @Date 2022/11/21
 * @Description ExtendsThread
 * @Version 1.0
 */
public class ExtendsThread  extends  Thread{
    @Override
    public void run() {
        System.out.println("继承thread ");
    }
}

第 2 种方式是继承 Thread 类，如代码所示，与第 1 种方式不同的是它没有实现接口，而是继承
Thread 类，并重写了其中的 run() 方法。相信上面这两种方式你一定非常熟悉，并且经常在工作中使用
它们。

3.线程池创建线程

以下是线程池创建线程的核心源码

 /**
     * The default thread factory
     */
    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

对于线程池而言，本质上是通过线程工厂创建线程的，默认采用 DefaultThreadFactory ，它会给线程
池创建的线程设置一些默认值，比如：线程的名字、是否是守护线程，以及线程的优先级等。但是无论
怎么设置这些属性，最终它还是通过 new Thread() 创建线程的 ，只不过这里的构造函数传入的参数要
多一些，由此可以看出通过线程池创建线程并没有脱离最开始的那两种基本的创建方式，因为本质上还
是通过 new Thread() 实现的。

4.有返回值的 Callable 创建线程

package com.moon.erupt.impl;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @ClassName CallableTask
 * @Author zhangqing
 * @Date 2022/11/21
 * @Description TODO
 * @Version 1.0
 */
public class CallableTask  implements Callable<String> {
    @Override
    public String call() throws Exception {
        return  new Random().nextLong()+"";
    }
    ExecutorService service = Executors.newFixedThreadPool(10);
    Future<String> future = service.submit(new CallableTask());
}

第 4 种线程创建方式是通过有返回值的 Callable 创建线程，Runnable 创建线程是无返回值的，而
Callable 和与之相关的 Future、FutureTask，它们可以把线程执行的结果作为返回值返回，

但是，无论是 Callable 还是 FutureTask，它们首先和 Runnable 一样，都是一个任务，是需要被执行
的，而不是说它们本身就是线程。它们可以放到线程池中执行，如代码所示， submit() 方法把任务放
到线程池中，并由线程池创建线程，不管用什么方法，最终都是靠线程来执行的，而子线程的创建方式
仍脱离不了最开始讲的两种基本方式，也就是实现 Runnable 接口和继承 Thread 类。

5.实现线程只有一种方式

关于这个问题，我们先不聚焦为什么说创建线程只有一种方式，先认为有两种创建线程的方式，而其他
的创建方式，比如线程池或是定时器，它们仅仅是在 new Thread() 外做了一层封装，如果我们把这些
都叫作一种新的方式，那么创建线程的方式便会千变万化、层出不穷，比如 JDK 更新了，它可能会多出
几个类，会把 new Thread() 重新封装，表面上看又会是一种新的实现线程的方式，透过现象看本质，
打开封装后，会发现它们最终都是基于 Runnable 接口或继承 Thread 类实现的。

我们看Thread，他也是实现了Runnable ，重写了run 方法，其本质也是一样的

   /**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }