线程的实现方式

矫情吗；* 2022-10-30 11:24 105阅读 0赞

# 基本概念 #

## 进程和线程 ##

*  进程（Process）：程序运行资源分配的最小单位，进程内部有多个线程，会共享这个进程的资源。
 *  线程（Thread）：CPU调度的最小单位，必须依赖进程而存在。

## 并行和并发 ##

*  并行（Paralle）：同一时刻，可以同时处理事情的能力。
 *  并发（Concurrent）：与单位时间相关，在单位时间（如1s）内可以处理事情的能力。

## 并发的意义与问题 ##

意义：

*  充分利用cpu的资源，加快用户响应的时间。
 *  程序模块化，异步化。

问题：

*  线程共享资源，存在冲突，出现线程安全问题。
 *  容易导致线程的死锁。
 *  启用过多的线程，有可能造成计算机宕机。

# 线程的实现方式 #

Java中实现多实现线程的方式到底有几种？大部分人会说有 2 种、3 种或是 4 种，很少有人会说有 1 种。我们接下来看看它们具体指什么？

## 实现Runnable接口 ##

实现Runnable接口的类无法直接启动，必须借助Thread类才能启动。

package com.morris.concurrent.thread.impl;
    
    /** * 线程的实现方法之一：实现runnable接口 */
    public class ImplementRunnable implements Runnable { 
        @Override
        public void run() { 
            System.out.println("This thread is implement Runnable interface.");
        }
    
        public static void main(String[] args) { 
            Thread thread = new Thread(new ImplementRunnable()); // 无法直接启动，需借助Thread才能启动
            thread.start();
        }
    }

## 继承Thread类 ##

继承Thread类的线程可直接启动。

package com.morris.concurrent.thread.impl;
    
    /** * 线程的实现方法之一：继承Thread类 */
    public class ExtendThread extends Thread { 
        @Override
        public void run() { 
            System.out.println("This thread is extend Thread class.");
        }
    
        public static void main(String[] args) { 
            ExtendThread thread = new ExtendThread();
            thread.start(); // 可直接启动
        }
    }

## 实现Callable接口 ##

继承Thread类和实现Runnable接口这两种方式启动的线程执行完后的结果是无法获取的。

而实现Callable接口可以拿到线程执行完后返回的结果。

package com.morris.concurrent.thread.impl;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /** * 线程的实现方法之一：实现Callable接口 */
    public class ImplementCallable implements Callable<String> { 
        @Override
        public String call() throws Exception { 
            System.out.println("This thread is implement Runnable interface.");
            return "morris";
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
            FutureTask<String> futureTask = new FutureTask<>(new ImplementCallable());
            Thread thread = new Thread(futureTask);
            thread.start();
            String result = futureTask.get(); // 阻塞等待结果
            System.out.println(result);
        }
    }

## 线程池创建线程 ##

可以通过线程池快速的创建多个线程：

package com.morris.concurrent.thread.impl;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /** * 使用线程池创建线程 */
    public class ThreadPoolDemo { 
        public static void main(String[] args) { 
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            executorService.submit(()-> System.out.println("This thread is create by thread pool."));
            executorService.shutdown();
        }
    }

接下来，我们深入解析线程池中的源码，来看看线程池是怎么创建线程的？

static class DefaultThreadFactory implements ThreadFactory { 
     
        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()实现的。

## 总结 ##

*  Thread类底层实现了Runnable接口。
 *  实现Runnable接口的线程必须借助Thread类才能启动。
 *  需要接受返回值可以使用Callable。
 *  实现Runnable接口可以避免由于Java的单继承特性而带来的局限，增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。
 *  Thread负责线程的启动执行，Runnable接口负责具体的业务逻辑，符合单一职责原则，使用了策略模式。
 *  在实际应用场景中，一般不会单独直接创建线程，而是使用线程池来创建线程。

> 事实上创建线程只有一种方式，就是构造一个Thread类，这是创建线程的唯一方式。

## 查看jvm启动的线程 ##

当运行main方法后，jvm底层到底启动了多少个线程？

可以使用java api来查看线程的情况。

package com.morris.concurrent.thread.impl;
    
    import java.lang.management.ManagementFactory;
    import java.lang.management.ThreadInfo;
    import java.lang.management.ThreadMXBean;
    import java.util.concurrent.TimeUnit;
    
    /** * 查看程序运行时，jvm底层到底产生了多少个线程 */
    public class ThreadViewDemo { 
    
        public static void main(String[] args) throws InterruptedException { 
    
            ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
    
            ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
    
            for (ThreadInfo threadInfo : threadInfos) { 
                System.out.printf("ThreadName：%s， status：%s \n", threadInfo.getThreadName(), threadInfo.getThreadState());
            }
    
            TimeUnit.SECONDS.sleep(30);
        }
    }

运行结果如下：

ThreadName：Monitor Ctrl-Break， status：RUNNABLE 
    ThreadName：Attach Listener， status：RUNNABLE 
    ThreadName：Signal Dispatcher， status：RUNNABLE 
    ThreadName：Finalizer， status：WAITING 
    ThreadName：Reference Handler， status：WAITING 
    ThreadName：main， status：RUNNABLE

从运行结果可以发现，jvm不仅启动一个main线程来运行我们的程序，还启动了一些守护线程，如垃圾回收线程、RMI线程等。

也可借助jdk自带的工具jconsole来查看：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/b63dedea77f94a85a3a8795806297c49.png