多线程基础：线程基本概念与线程的创建

忘是亡心i 2023-09-28 10:48 106阅读 0赞

## 一. 线程与进程 ##

### 1. 进程 ###

一开始看线程与进程的概念可能会感觉到很抽象，晦涩难懂，先看下图：

![7a6ca8a1a3804292a62731d1009c87d0.png][]

上图是**WIN10系统**中的任务管理器，操作系统的**.exe**文件可以理解成一个进程，可以这样说，进程是操作系统运行的一个基本运行单元。

说到进程，有必要来说一下程序，程序由许多个指令与数据组成，就是**指令序列。**

这些指令需要运行，数据需要读写，指令加载至CPU，让CPU做指定的任务。

数据加载至内存，指令运行时，需要用到网络，磁盘等设备。这一过程就需要进程来加载指令，管理内存，处理IO的。

所以当一个程序运行时，磁盘加载代码至内存就相当于开启一个进程。比如当Java每编译一次**.class**文件。就会创建一个JVM进程。

我们可以将进程认为是程序运行的一个实例，并且大部分程序都可以运行多个进程实例，比如记事本，谷歌浏览器等，有的程序只能开一个线程，比如酷狗音乐等。

### 2. 线程 ###

线程相当于进程中相互独立运行的子任务，这些子任务可以有多个， 它们共享着该进程所拥有的资源。

在Java中进程是资源分配的最小单位，线程作为最小的调度单位，**先有进程，后有线程。**

**☆二者对比总结☆**

> **1. 进程与进程之间是相互独立的，线程属于进程的一个子集存在于线程内。**
> 
> **2. 进程共享系统资源，如内存，网络端口供其线程使用。**
> 
> **3. 进程之间的通信较为复杂，本机通常使用IPC机制，不同计算机之间的通信通常使用Socket或者Http协议进行通信。**
> 
> **4. 线程虽然比进程轻，但是线程的上下文切换的成本非常高。**

## 二. 并行与并发 ##

### 2.1 并发 ###

单任务运行环境下（**单核CPU**）线程执行方式是串行的，操作系统中的任务调度器，会将CPU的时间片分给不同程序去执行。

同一时间段内，线程轮流执行的方式叫做**并发【concurrent】。**换句话说就是**一段时间内，处理多件事情的需求。**

举个例子说明一下，什么是并发就会很好理解了：

![176e1a6bd38544a68c8fc0d2f568de89.png][]

在单核CPU下，现在有两个线程需要执行， 但是在某个时刻下只能让一个线程获得CPU资源去运行，假设当线程1开始运行到指令3时，必须依赖线程2去执行。

此时CPU会去执行线程2，而线程1必须等待线程2运行过后才可运行（大部分都是以时间片轮巡的方式）通过不断切换需要运行的线程的方式，这种就是**并发【Parallel】**：**指两个或多个事件在同一时间段内发生**。

这个过程运行时间很快，我们很难感觉到，我们感觉好像是两个线程同时运行的，总结为一句话就是：**微观串行，宏观并行。**

### 2.2 并行 ###

上面说了，并发是一段时间内，处理多件事情的需求。如何解决这种需求，通过并行，所以可以说并行是解决并发的一种方式。

关于并行的定义是这样：**指两个或多个事件在同一时刻点同时发生。**看下图：

![32ea1f89b15940d7850064f7fe235ff7.png][]

现在，在多核CPU下，以上两个线程不需要等待某一方执行完毕后再去执行，而是可以同时让两个线程同时运行，这就是**并行。**

## **三. 同步与异步** ##

同步与异步的概念相对来说比较简单，我们从方法的角度去理解：

假设有A与B两方法，调用A方法时必须返回调用后的结果才能执行B方法，这种就是**同步。**

相反，无需等待结果返回直接就可以执行B方法就是**异步**。

多线程是异步的，关于多线程异步调用的应用有很多举几个：

> 1. 较大文件的格式转换可以单开线程运行，防止阻塞。
> 
> 2. tomcat中的异步Servlet，让用户线程去处理耗时任务，防止tomcat阻塞。

## **四. 创建线程** ##

### **4.1 继承Thread** ###

创建线程类之前，先看**Thread类**的构造：

public class Thread implements Runnable {}

Thread类实现Runable接口，Runable接口中只有一个抽象方法：

@FunctionalInterface
    public interface Runnable {
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see     java.lang.Thread#run()
         */
        public abstract void run();
    }

所以继承Thread类，需要重写其中的**run()方法**，将线程所处理的任务放到**run()方法**执行体中，然后通过创建该类的对象，执行**start()方法**，才是真正意义上的开启一个线程。

具体代码：

/**
     * MyThread是个线程类
     * @author 爪哇斗罗（javaDouluo）
     *
     */
    public class MyThread extends Thread {
    	
    	/**
    	 * 重写run方法
    	 */
    	@Override
    	public void run() {
    		System.out.println("MyRunThread===>" + Thread.currentThread().getName());
    	}
    
    	public static void main(String[] args) {
    		MyThread myThread = new MyThread();
    		// 开启线程
    		myThread.start();
    		// 当前线程名
    		System.out.println("main===>"+ Thread.currentThread().getName());
    	}
    }

运行结果：

![32b5e3be85a54a65ac128f31d245021f.png][]

**注意：**

> **上面有两个线程，一个是主线程，还有一个是我们自己创建的线程，不要认为线程的执行顺序是按照代码的放置顺序来执行的，这与你调用线程方法start()的放置顺序无关。**

### **4.2 实现Runable接口** ###

当出现线程类已经有一个父类时，继承Thread方法就不可行，可以使用实现**Runable接口**的方式来创建线程，就是对继承的一种拓展。

/**
     * @author 爪哇斗罗（javaDouluo）
     * @date 2022年06月25日 0:17
     */
    public class MyRunable implements Runnable{
        /**
         * 实现Run方法
         */
        @Override
        public void run() {
            System.out.println("MyRunThread===>" + Thread.currentThread().getName());
        }
    
        public static void main(String[] args) throws InterruptedException {
            // 实例化当前线程对象
            Runnable runnable = new MyRunable();
            // 将当前线程对象入参至Thread
            Thread thread = new Thread(runnable);
            // 开启线程
            thread.start();
            // 当前线程名
            System.out.println("main===>" + Thread.currentThread().getName());
        }
    }

这种方式的结果与上述是一样的。

### **4.3 FutureTask配合Thread** ###

当线程结束之后我们需要返回一个结果可以使用**FutureTask**来接收一个**Callable类型**的参数来处理有返回结果的情况。

package com.jektong.thread.day01;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @author 爪哇斗罗（javaDouluo）
     * @date 2022年06月27日 23:10
     */
    public class FutureTaskThread {
        /**
         * FutureTask通过配合Callable来实现有返回值得效果
         * @param args
         */
    	public static void main(String[] args) throws ExecutionException, InterruptedException {
    		FutureTask<Integer> integerFutureTask = new FutureTask<>(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("java");
                    TimeUnit.SECONDS.sleep(5);
                    return 0;
                }
            });
            Thread thread = new Thread(integerFutureTask);
            thread.start();
            // 获取返回值
            integerFutureTask.get();
    	}
    }

[7a6ca8a1a3804292a62731d1009c87d0.png]: https://img-blog.csdnimg.cn/7a6ca8a1a3804292a62731d1009c87d0.png
[176e1a6bd38544a68c8fc0d2f568de89.png]: https://img-blog.csdnimg.cn/176e1a6bd38544a68c8fc0d2f568de89.png
[32ea1f89b15940d7850064f7fe235ff7.png]: https://img-blog.csdnimg.cn/32ea1f89b15940d7850064f7fe235ff7.png
[32b5e3be85a54a65ac128f31d245021f.png]: https://img-blog.csdnimg.cn/32b5e3be85a54a65ac128f31d245021f.png