前言

为什么要使用线程?

在程序中完成某⼀个功能的时候,我们会将他描述成任务,这个任务需要在线程中完成.

一、串⾏与并发

如果在程序中，有多个任务需要被处理，此时的处理方式可以有串行和并发：

• 
  串行
  
  （同步）：所有的任务，按照⼀定的顺序，依次执行。如果前⾯的任务没有执⾏结束，后⾯的任务等待。
• 
  并发
  
  （异步）：将多个任务同时执行，在⼀个时间段内，同时处理多个任务。

二、进程和线程

• 
  进程
  
  ：是对⼀个程序在运行过程中，占用的各种资源的描述。
• 
  线程
  
  ：是进程中的⼀个最小的执行单元。其中操作系统中，最小的任务执⾏单元并不是线程，而是句柄。只不过句柄过小，操作起来⾮常的麻烦，因此线程就是我们可控的最小的任务执⾏单元。

1.进程和线程的异同

• 相同点: 进程和线程都是为了处理多个任务并发⽽存在的。
• 不同点: 进程之间是资源不共享的，⼀个进程中不能访问另外⼀个进程中的数据。⽽线程之间是资源共享的，多个线程可以共享同⼀个数据。也正因为线程之间是资源共享的，所以会出现临界资源的问题。

2.进程和线程的关系

⼀个进程，在开辟的时候，会⾃动的创建⼀个线程，来处理这个进程中的任务。 这个线程被称为是主线程。在程序运⾏的过程中， 还可以开辟其他线程， 这些被开辟出来的其他线程， 都是⼦线程。

也就是说，⼀个进程中，是可以包含多个线程。⼀个进程中的某⼀个线程崩溃了，只要还有其他线程存在， 就不会影响整个进程的执行。 但是如果⼀个进程中，所有的线程都执行结束了，那么这个进程也就终止了。

3.进程与线程总结

• 程序:⼀个可执行的⽂件
• 进程:⼀个正在运行的程序.也可以理解成在内存中开辟了⼀块儿空间
• 线程:负责程序的运⾏,可以看做⼀条执⾏的通道或执⾏单元,所以我们通 常将进程的⼯作理解成线程的⼯作
• 进程中可不可以没有线程? 必须有线程,⾄少有⼀个.
• 当有⼀个线程的时候我们称为单线程(唯⼀的线程就是主线程). 当有⼀个以上的线程同时存在的时候我们称为多线程.
• 多线程的作⽤:为了实现同⼀时间⼲多件事情(并发执⾏).

三、线程的创建

1.线程创建的四种方法

创建线程主要有四种方法：

• 继承Thread类创建线程对象
• 使用Runnable接口
• 通过 Callable 和 Future 创建线程
• 通过线程池创建线程

2.继承Thread类创建线程对象

继承⾃Thread类，做⼀个Thread的⼦类。在⼦类中， 重写⽗类中的run⽅法，在这个重写的⽅法中，指定这个线程需要处理的任务。

代码示例：

/**
 * @author: Mercury
 * Date: 2022/3/27
 * Time: 13:15
 * Description:通过继承Thread来创建线程
 * Version:1.0
 */
public class Test3 {
    public static void main(String[] args) {
        Task2 task2 = new Task2("通过继承Thread创建的线程1");
        task2.start();
    }
}
class Task2 extends Thread{
    private String threadName;

    public Task2() {
    }

    public Task2(String threadName) {
        this.threadName = threadName;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(threadName+": "+i);
        }
    }
}

1) Thread类常用方法

3.使用Runnable接口

在Thread类的构造⽅法中，有⼀个重载的构造⽅法，参数是Runnable 接⼝。因此，可以通过Runnable接⼝的实现类对象进⾏Thread对象的实例化。

代码示例：

/**
 * @author: Mercury
 * Date: 2022/3/27
 * Time: 13:05
 * Description:通过实现Runnable接口来创建线程
 * Version:1.0
 */
public class Test2 {
    public static void main(String[] args) {
        Task task = new Task();
        Thread thread = new Thread(task,"线程1");
        thread. start();
    }
}
class Task implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

5.继承Thread和使用Runnable接口的优缺点对比

• 继承的⽅式：优点在于可读性⽐较强，缺点在于不够灵活。如果要定制⼀个线程，就必须要继承⾃Thread类，可能会影响原有的继承体系。
• 接⼝的⽅式：优点在于灵活，并且不会影响⼀个类的继承体系。缺点在于可读性较差。

6.通过 Callable 和 Future 创建线程

创建Callable接口的实现类，并实现call()方法，该方法可以作为线程执行体，并且有返回值。接下来创建Callable实现类的实例，并使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法返回值。使用FutureTask对象作为Thread的target创建并启动新线程。然后调用FutureTask对象的get()来获得子线程执行结束后的返回值。如果不需要接受返回值，可以不用这部分操作。

代码示例：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author: Mercury
 * Date: 2022/3/27
 * Time: 13:29
 * Description:通过 Callable 和 Future 创建线程
 * Version:1.0
 */
public class Test4 {
    public static void main(String[] args) {
        CallableTest callableTest = new CallableTest();
        //使用FutureTask类包装Callable对象
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callableTest);
        //将FutureTask的对象作为参数传递到Thread类中，创建Thread对象，并调用start（）
        new Thread(futureTask).start();
        //如果需要获取返回值的话
        try {
            Integer i = futureTask.get();
            System.out.println("i="+i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//创建Callable接口的实现类
class CallableTest implements Callable<Integer>{

    //实现call()方法
    @Override
    public Integer call() throws Exception {
        int i = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+": "+i);
        }
        return i;
    }
}

6.通过线程池创建线程

线程池

：其实就是⼀个容器，⾥⾯存储了若⼲个线程。

使⽤线程池，最主要是解决

线程复⽤

的问题。之前使⽤线程的时候，当我 们需要使⽤⼀个线程时，实例化了⼀个新的线程。当这个线程使⽤结束后，对这个线程进⾏销毁。对于需求实现来说是没有问题的，但是如果频繁的进⾏线程的开辟和销毁，其实对于CPU来说，是⼀种负荷，所以要尽量的优化这⼀点。

可以使⽤复⽤机制解决这个问题。当我们需要使⽤到⼀个线程的时候，不是直接实例化，⽽是先去线程池中查找是否有闲置的线程可以使⽤。如果有，直接拿来使⽤；如果没有，再实例化⼀个新的线程。并且当这个线程使⽤结束后，并不是⻢上销毁，⽽是将其放⼊到线程池中，以便下次继续使⽤。

线程池中的所有线程可以分成俩个部分：

核心线程和临时线程

核心线程

：核⼼线程常驻于线程池中，这些线程，只要线程池存在，他们不会被销毁。只有当线程池需要被销毁的时候，他们才会被销毁。

临时线程

：就是临时⼯。当遇到了临时的⾼密度的线程需求时， 就会临时开辟⼀些线程，处理⼀些任务。这些临时的线程在处理完⾃⼰需要处理的任务后， 如果没有其他的任务要处理，就会闲置。当闲置的时间到达了指定的时间之后，这个临时线程就会被销毁。

代码示例：

package test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author: Mercury
 * Date: 2022/3/27
 * Time: 12:48
 * Description:线程池
 * Version:1.0
 */
public class Test1 {
    public static void main(String[] args) {
        //创建线程池对象，参数10 表示线程池中有10个线程
        ExecutorService service = Executors.newFixedThreadPool(10);
        //创建Runnable线程对象
        Task3 task3 = new Task3();
        //从线程池中获取线程对象
        service.submit(task3);
        service.submit(task3);
        //关闭线程池
        service.shutdown();
    }
}
class Task3 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+": "+i);
        }
    }
}

1.线程池常用方法

2.线程池的工具类

线程池的开辟，除了可以使⽤构造⽅法进⾏实例化，还可以通过Executors⼯具类进⾏获取。实际应⽤中，⼤部分的场景下，可以不⽤前⾯的构造⽅法进⾏线程池的实例化，⽽是⽤Executors⼯具类中的⽅法进⾏获取。

总结

以上就是与多线程的相关内容，简单介绍了进程和线程以及多线程的四种创建方式，祝各位小伙伴们学习愉快！