不懂多线程的后端开发程序员不是合格的程序员

什么是多线程

多线程是一种在计算机编程中常用的并发编程技术，它允许一个程序同时执行多个独立的线程（线程是一个轻量级的执行单元），从而实现更高效的任务处理和资源利用。简单说，多线程允许一个程序在同一时间内执行多个任务，这些任务可以并行运行，从而提高了程序的响应速度和性能。

多线程中的知识点

线程和进程的区别

线程（Thread）和进程（Process）是操作系统中用于管理和执行程序的两个基本概念，它们之间有一些重要的区别：

总结来说，线程是进程内的执行单元，它们共享进程的资源，因此更轻量，但需要更仔细地处理同步和共享资源问题。进程是操作系统分配资源的基本单位，拥有独立的内存空间，因此更安全，但创建和销毁进程开销较大。选择使用线程还是进程取决于具体的应用场景和需求。

在JAVA语言中，多线程的创建方式

多线程可以使用不同的方式来创建和管理，以下是四种常见的多线程创建方式：

class MyThread extends Thread {
    public void run() {
        // 线程执行的任务
    }
}

MyThread thread = new MyThread();
thread.start();

class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的任务
    }
}

Runnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

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

class MyCallable implements Callable {
    public String call() {
        // 线程执行的任务，并返回结果
        return "Task completed";
    }
}

ExecutorService executor = Executors.newFixedThreadPool(2);
Callable callable = new MyCallable();
Future future = executor.submit(callable);

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

ExecutorService executor = Executors.newFixedThreadPool(2); // 创建一个包含两个线程的线程池
Runnable runnable = () -> {
    // 线程执行的任务
};
executor.submit(runnable);

这些方式都可用于创建多线程，具体的选择取决于你的需求和设计。线程池是一种高效的方式，可以减少线程创建和销毁的开销，并更好地管理线程的生命周期。同时，使用Callable接口可以获得任务的执行结果，而Runnable则用于执行无需返回结果的任务。

线程池的工作流程

线程池是一种用于管理和复用线程的机制，它可以提高多线程应用程序的性能和资源管理效率。以下是典型的线程池的工作流程：

线程池的主要优点在于可以有效地管理和复用线程，降低了线程创建和销毁的开销，提高了应用程序的性能和响应速度。它还可以控制并发线程的数量，避免资源耗尽问题。因此，在多线程应用程序中，使用线程池通常是一种良好的实践。

以下是一个使用Java演示线程池的简单示例。在这个示例中，我们将创建一个固定大小的线程池，然后提交一些任务给线程池执行。

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池，包含两个线程
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 提交任务给线程池执行
        for (int i = 1; i  {
                System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
                // 模拟任务执行时间
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Task " + taskNumber + " is completed.");
            });
        }

        // 关闭线程池
        executor.shutdown();
    }
}

在这个示例中，我们使用Executors.newFixedThreadPool(2)创建了一个包含两个线程的线程池。然后，我们提交了5个任务给线程池执行。每个任务都会打印出当前线程的名称，并模拟执行任务的时间。最后，我们调用executor.shutdown()来关闭线程池。

运行此示例，你将看到线程池中的两个线程交替执行这五个任务，线程复用的特点使得线程创建和销毁的开销较小，提高了执行效率。

多线程中对的几种状态

在Java中，多线程可以具有以下几种不同的状态：

线程的状态转换是由操作系统和Java虚拟机自动管理的，开发者通常只需要关注线程的创建和任务执行。理解线程状态有助于调试和分析多线程程序中的问题，特别是在处理并发问题时。

多线程安全问题

共享数据不安全

加锁

Synchronized锁 与 Lock锁

Synchronized 与 Lock 的区别？

Synchronized 和 Lock（java.util.concurrent.locks.Lock 接口）都是用于多线程编程中实现同步的机制，但它们有一些重要的区别：

public synchronized void synchronizedMethod() {
    // 同步方法
}

Lock lock = new ReentrantLock();
lock.lock();
try {
    // 同步代码块
} finally {
    lock.unlock();
}

Lock lock = new ReentrantLock();
try {
    lock.lockInterruptibly(); // 可中断地等待锁
    // 同步代码块
} catch (InterruptedException e) {
    // 处理中断
} finally {
    lock.unlock();
}

总的来说，Synchronized 更简单易用，适用于大多数情况下的同步需求，而 Lock 提供了更多的控制和功能，适用于一些特殊的同步场景，但也需要更谨慎的使用和管理。选择哪种同步机制取决于具体的需求和性能要求。

Synchronized锁

Synchronized（也称为关键字 synchronized）是Java中用于实现线程同步的关键字。它可以用来创建临界区，确保只有一个线程可以同时访问临界区内的代码块。以下是关于 Synchronized 锁的简要讲解：

示例代码：

public class SynchronizedExample {
    private int count = 0;

    // 同步实例方法
    public synchronized void increment() {
        count++;
    }

    // 同步代码块
    public void performSomeTask() {
        synchronized (this) {
            // 这个代码块是同步的
            count++;
        }
    }
}

Synchronized 是一种简单而有效的同步机制，但需要注意，它可能会引入一些性能开销，因为每次只有一个线程可以执行同步块内的代码。在某些高并发场景下，可能需要考虑使用更高级的同步机制，如 java.util.concurrent 包中的锁。

Lock锁

Lock 是 Java 中用于实现线程同步的更灵活和强大的机制。与 Synchronized 关键字相比，Lock 提供了更多的功能和控制，允许程序员显式地获取和释放锁。以下是关于 Lock 锁的简要讲解：

示例代码：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

Lock 提供了更多的控制和功能，适用于一些需要更灵活同步策略的场景。但也需要注意，使用 Lock 需要更谨慎，确保在正确的地方获取和释放锁，以避免死锁和其他问题。

锁的分类

1、悲观锁与乐观锁

悲观锁
Synchronized
Lock
数据库的行锁、表锁

• Synchronized 和 Lock 代表在编程中实现线程同步的机制，用于保护共享资源免受并发访问的影响。
• 数据库的行锁和表锁代表在数据库管理系统中实现数据访问控制的机制，用于处理多个事务同时访问数据库中的数据。行锁用于保护单个行的数据，而表锁用于保护整个表的数据。

    乐观锁
    cas
    比较和交换
    数据库使用version字段
    

CAS（Compare and Swap）：

CAS 是一种乐观锁的实现方式，它适用于多线程环境下，确保对共享数据的操作是原子的。CAS 操作包括以下两个步骤：

CAS 操作通常用于实现线程安全的数据结构和算法，例如 Java 中的 java.util.concurrent.atomic 包中的原子类，如 AtomicInteger、AtomicLong 等。

数据库中使用版本字段：

在数据库中，使用版本字段（Versioning）代表一种乐观锁的实现方式。每个数据库记录（行）通常包含一个版本字段，这个字段存储了记录的版本号或时间戳。

• 当一个事务读取数据时，它会记录下读取时的版本号或时间戳。
• 当同一个事务尝试更新数据时，它会比较要更新的数据的当前版本号与读取时记录的版本号是否相同。
• 如果版本号相同，表示数据在读取后没有被其他事务修改，事务可以执行更新。
• 如果版本号不同，表示数据在读取后已经被其他事务修改，事务更新操作失败，需要进行冲突处理。

使用版本字段可以实现乐观锁，它假设并发冲突的概率较低，因此不会立即锁定数据，而是在提交更新时才检查冲突。这种方式适用于读操作频繁、写操作较少的场景，可以减少锁的争用，提高并发性能。数据库中的版本字段通常是用于记录数据的版本信息，帮助数据库管理系统检测并发冲突。

死锁

死锁产生的原因：
1、系统资源不足；

2、进程运行推进的次序不合适；

3、资源分配不当。

4、如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。其次，进程运行推进顺序与速度不同，也可能产生死锁。

死锁产生的原因及四个必要条件

1、互斥条件：一个资源一次只能被一个进程访问。

2、请求与保持： 一个进程因请求资源而阻塞时，对已获得的资源保持不放。

3、不可剥夺：进程已获得的资源，在未使用完之前，不得强行剥夺。

4、循环等待：若干进程之间形成一种头尾相接的循环等待资源关系

线程通信

线程通信和进程间通信是多线程和多进程编程中的关键概念，它们描述了不同线程或进程之间如何协作和交换信息的方式。以下是对同步通信、异步通信和进程间通信的简要解释：

同步通信：

wait、notify、notifyAll、jion方法、通过 volatile 关键字、

同步通信是指线程或进程之间通过一种协作方式，以确保某个操作在另一个操作完成之后才能继续进行。这种通信方式用于实现线程或进程之间的协同工作，以确保数据的一致性和正确性。

• 示例：在多线程编程中，可以使用锁、条件变量或信号量等同步机制来实现同步通信。例如，一个线程等待另一个线程完成某个任务后才能继续执行。

异步通信：

消息中间件

异步通信是指线程或进程之间的操作是独立的，不需要等待其他操作的完成。在异步通信中，操作会立即返回，而不会阻塞当前线程或进程。异步通信通常用于提高系统的响应性和并发性。

• 示例：在多线程编程中，可以使用回调函数、事件驱动机制或消息队列等方式来实现异步通信。例如，一个线程可以启动一个异步任务并立即返回，当任务完成后，可以通过回调函数或事件通知来处理结果。

进程间通信：

http、feign、socket、mq

进程间通信是指不同的进程之间进行数据交换和协作的过程。在操作系统中，进程是独立的执行单元，它们有自己的内存空间。进程间通信允许不同进程之间共享数据和通信，以完成各种任务。

• 示例：进程间通信可以通过多种方式实现，包括管道、套接字、消息队列、共享内存、信号量、RPC（远程过程调用）等。例如，两个不同的进程可以通过套接字建立网络连接来进行通信，或者通过共享内存来共享数据。

总结：

• 同步通信用于确保操作的顺序和一致性，通常需要等待其他操作完成。
• 异步通信用于提高响应性和并发性，允许操作在后台执行，不会阻塞当前线程或进程。
• 进程间通信允许不同进程之间进行数据交换和协作，通常使用操作系统提供的通信机制来实现。

6、多线程并发问题

一、线程安全的特性

原子性：一个线程操作是不能被其他线程打断

有序性：线程在执行程序是有序的

可见性：一个线程修改数据后，对其他线程是可见的

volatile

保证可见性，可以在一个线程修改了共享数据时对其他线程可见，其原理就是修改了变量副本值后及时同步到主内存，其他线程从主内存中获取

指令重排：Java代码翻译成class文件后，最终在JVM执行时，是把class翻译一个个的指令进行执行的。而CPU为了程序的执行性能，会对指令进行重新排序

也就是说万一翻译后的指令是123，那么重排后的指令可能就是213。在多线程情况下，就会出现变量的可见性问题

• 有序性：内存屏障(也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作)，避免代码重排序。

• 内存屏障提供了避免重排序的功能

• 可见性：内存屏障之前的所有写操作都要回写到主内存，内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果(实现了可见性)

• 内存屏障会把线程把工作内存中改变后的数据直接刷回主内存。其他线程就可以从主内存中获取最新数据

单例模式

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供了一种全局访问该实例的方式。单例模式通常用于需要在整个应用程序中共享一个唯一对象的情况，以避免多次创建相同对象，节省系统资源并确保数据一致性。

单例模式的核心思想是：

以下是一个简单的单例模式示例（饿汉式）：

public class Singleton {
    // 私有静态成员变量，用于保存唯一的实例
    private static Singleton instance = new Singleton();

    // 私有构造函数，防止外部创建新的实例
    private Singleton() {
        // 初始化操作
    }

    // 提供全局访问点，返回单例实例
    public static Singleton getInstance() {
        return instance;
    }
}

在上面的示例中，Singleton 类的构造函数是私有的，外部无法直接创建新的实例。而通过静态方法 getInstance()，可以获取唯一的 Singleton 实例。

单例模式有多种实现方式，包括饿汉式（在类加载时就创建实例）、懒汉式（在需要时才创建实例）、双重检查锁式等。选择哪种方式取决于具体的需求和性能考虑。

单例模式的优点包括：

• 节省资源：因为只有一个实例，不会多次创建相同对象，节省内存和其他资源。
• 数据共享：可以在整个应用程序中共享单例对象，确保数据一致性。
• 全局访问：通过全局访问点，简化了对象的管理和调用。

然而，单例模式也有一些潜在的缺点，如可能引入全局状态、不易扩展等，因此在使用时需要谨慎考虑。

单例模式的双重校验锁（Double-Checked Locking）是一种用于延迟初始化的单例模式实现方式，它在多线程环境下保证只创建一个实例，并且延迟到实际需要时才进行初始化。这种方式在性能和线程安全之间取得了一定的平衡。

下面是使用双重校验锁实现的单例模式的示例（基于懒汉式）：

public class Singleton {
    // 私有静态成员变量，用于保存唯一的实例
    private volatile static Singleton instance;

    // 私有构造函数，防止外部创建新的实例
    private Singleton() {
        // 初始化操作
    }

    // 提供全局访问点，返回单例实例
    public static Singleton getInstance() {
        if (instance == null) {
            // 第一次检查，如果实例为空，才进入同步块
            synchronized (Singleton.class) {
                // 第二次检查，确保在获取锁后实例仍然为空
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这里的关键点包括：

这种双重校验锁的方式在多线程环境下能够保证线程安全，同时也避免了不必要的同步开销，因为只有在第一次创建实例时才需要同步。这使得在绝大多数情况下，多个线程可以高效地访问单例对象。

需要注意的是，双重校验锁的实现需要确保 JDK 版本在1.5及以上，因为在1.4及以下的版本中，volatile 关键字的语义不够强大，可能会导致双重校验锁失效。因此，确保使用双重校验锁的线程安全性需要考虑到 JVM 版本的兼容性。

Spring集成线程池

@Async：标记在方法上， 表示当前方法是异步执行的

@EnableAsync：开启多线程异步

Spring框架提供了对线程池的支持，你可以轻松地在Spring应用中集成和配置线程池。线程池的集成通常涉及以下几个关键步骤：

@Configuration
@EnableAsync
public class AppConfig {
    @Bean
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        return executor;
    }
}

@Service
public class MyService {
    @Async
    public void doSomethingAsync() {
        // 异步任务的实现
    }
}

@Autowired
private TaskExecutor taskExecutor;

public void someMethod() {
    taskExecutor.execute(() -> {
        // 异步任务的实现
    });
}

这样，你就成功集成了线程池到Spring应用中，可以轻松地执行异步任务，并且可以根据需求进行线程池的配置和调优。线程池的配置选项包括核心线程数、最大线程数、队列容量、线程池名称等，根据实际需求来设置。