Java后端学习系列（4）：Java多线程与并发编程基础-CSDN博客

本文链接：https://blog.csdn.net/Azperk/article/details/146365087

Java后端学习系列（4）：Java多线程与并发编程基础

前言

在前面的学习中，我们已经对Java的异常处理以及常用类库有了深入了解，而在现代的Java后端开发中，多线程与并发编程是非常重要的一部分，它能充分利用计算机的多核资源，提升程序的运行效率和性能。本期我们就来开启Java多线程与并发编程基础的学习之旅，助力大家进一步拓宽Java后端知识版图。本系列共15期，会持续为大家呈上实用且关键的知识内容。

一、线程的基本概念与创建方式

1.1 线程的概念

线程是程序执行流的最小单元，它是进程中的一个实体，是被系统独立调度和分派的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源（如内存空间、文件描述符等），同时又可以独立地执行各自的任务，从而实现并发执行的效果，提高程序整体的运行效率。

1.2 线程的创建方式

继承Thread类：
首先创建一个类继承自Thread类，然后重写run方法，在run方法中定义线程要执行的任务逻辑，示例如下：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("这是通过继承Thread类创建的线程在执行");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

需要注意的是，要通过调用start方法来启动线程，而不是直接调用run方法，直接调用run方法就相当于普通的方法调用，不会开启新的线程执行。

实现Runnable接口：
定义一个类实现Runnable接口，并重写run方法，然后将该类的实例作为参数传递给Thread类的构造函数来创建线程，示例：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("这是通过实现Runnable接口创建的线程在执行");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

这种方式相较于继承Thread类更具灵活性，因为Java是单继承机制，实现接口可以让类还能继承其他类，便于代码的扩展和复用。

使用Callable和Future接口（能获取线程返回结果）：
Callable接口定义了一个带返回值的任务，它的call方法可以抛出异常并返回一个结果。结合Future接口可以获取线程执行后的返回值，示例如下：

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

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return 10;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        Integer result = futureTask.get();
        System.out.println("线程返回结果：" + result);
    }
}

二、线程的生命周期与状态转换

2.1 线程的状态

线程在其生命周期内会经历多种状态，主要有以下几种：

新建（New）：当通过new关键字创建一个线程对象后，线程就处于新建状态，此时线程还未开始执行。
就绪（Runnable）：调用线程的start方法后，线程进入就绪状态，此时线程已经具备了运行的条件，等待获取CPU资源来执行。
运行（Running）：当线程获得CPU资源开始执行run方法时，线程处于运行状态，在运行过程中可能会因为时间片用完等原因暂停执行，重新回到就绪状态等待再次获取CPU资源。
阻塞（Blocked）：线程因为某些原因（比如等待获取锁、等待I/O操作完成等）暂时无法继续执行，就会进入阻塞状态，阻塞状态的线程会暂停执行，直到阻塞原因解除，然后重新进入就绪状态。
死亡（Dead）：线程执行完run方法或者因异常等原因退出执行后，线程就进入死亡状态，此时线程生命周期结束，不能再被重新启动。

2.2 状态转换关系

线程从新建状态通过start方法进入就绪状态，就绪状态的线程在获取到CPU资源后变为运行状态，运行状态的线程可能因为等待锁、I/O等原因进入阻塞状态，阻塞状态解除后回到就绪状态，线程执行完毕或者出现异常就进入死亡状态，各状态之间可以根据不同的条件和操作进行相应的转换。

三、线程同步机制（如`synchronized`关键字等）

3.1 synchronized关键字

修饰方法：
当synchronized关键字修饰实例方法时，锁住的是当前对象实例，同一时刻只有一个线程可以访问该对象的这个同步方法。示例：

class Counter {
    private int count;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

当多个线程访问同一个Counter对象的increment方法时，会依次排队执行，保证了数据的一致性。

修饰代码块：
可以指定锁住的对象，更加灵活地控制同步范围，例如：

class SharedResource {
    private Object lock = new Object();
    private int data;

    public void modifyData() {
        synchronized (lock) {
            data++;
        }
    }
}

通过指定lock对象作为锁，在多个线程访问modifyData方法时，只有获取到lock对象锁的线程才能进入同步代码块执行，避免了多线程并发访问导致的数据不一致问题。

3.2 其他同步方式（简单介绍）

除了synchronized关键字，还可以使用java.util.concurrent包下的一些类来实现线程同步，比如ReentrantLock（可重入锁），它提供了更灵活的加锁、解锁操作以及一些高级特性，如可中断锁、公平锁等，示例：

import java.util.concurrent.locks.ReentrantLock;

class LockCounter {
    private int count;
    private ReentrantLock lock = new ReentrantLock();

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

    public int getCount() {
        return count;
    }
}

四、并发容器的基本使用

4.1 ConcurrentHashMap

ConcurrentHashMap是在多线程环境下使用的哈希表，它相较于传统的HashMap，能够在高并发场景下保证线程安全且性能较好。例如：

import java.util.concurrent.ConcurrentHashMap;

ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
map.put(1, "One");
map.put(2, "Two");
String value = map.get(1);

它内部采用了分段锁等机制，允许多个线程同时对不同的分段进行操作，提高了并发访问的效率。

4.2 CopyOnWriteArrayList

CopyOnWriteArrayList是一个线程安全的动态数组，它在进行修改操作（如添加、删除元素）时，会复制一份原数组进行修改，修改完成后再将引用指向新数组，这样在读操作和写操作并发进行时，读操作不会被阻塞，适用于读多写少的场景，示例：

import java.util.concurrent.CopyOnWriteArrayList;

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("Java");
list.add("Python");
for (String element : list) {
    System.out.println(element);
}

五、下一步学习建议

代码实践：自己动手编写多线程相关的代码示例，尝试创建不同数量的线程，模拟不同的并发场景，运用所学的线程创建方式、同步机制以及并发容器等知识，观察程序的运行情况，加深对多线程并发编程的理解。
案例分析：找一些开源项目中涉及多线程并发编程的部分，分析它们是如何运用线程同步机制、选择合适的并发容器等，学习优秀的实践经验，拓宽自己的思路。
性能测试：在自己编写的多线程代码中，通过一些性能测试工具，对比不同同步方式、不同并发容器在相同场景下的性能表现，从而更深入地理解它们各自的优缺点，以便在实际项目中能够合理选用。