java-07 多线程-并发编程

wyh106115

已于 2024-10-10 18:56:28 修改

阅读量1.3k

点赞数 14

分类专栏： java基础文章标签： java 开发语言

于 2024-10-10 18:54:47 首次发布

本文链接：https://blog.csdn.net/wyh106115/article/details/142829561

版权

java基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

并发编程是指在一个程序中同时执行多个任务或线程。这通常涉及到多线程编程、线程同步、并发容器等技术。这些技术可以用来解决多线程环境中的问题，如线程安全、资源竞争、死锁等问题。在实际的Java并发编程中，还需要考虑到线程池、Future、Callable、ExecutorService等概念。

在另一篇文章介绍了多线程、进程、并发、并行等基本概念，并分析了线程安全问题产生的原因，同时也整理了线程实现的4种方式，并做了对比，请参考 java-06 多线程-4种实现方式

如果你觉得我分享的内容或者我的努力对你有帮助，或者你只是想表达对我的支持和鼓励，请考虑给我点赞、评论、收藏。您的鼓励是我前进的动力，让我感到非常感激。

1 线程同步

1.1 锁

StampedLock 在某些场景下可以提供更好的并发性能，但也需要注意合理的使用，以避免过于复杂的代码结构和潜在的死锁情况。

synchronized 和 ReentrantLock 都是基于悲观锁思想实现的，意味着它们假定在执行临界区代码期间会发生并发冲突。在高并发场景下，激烈的锁竞争可能会导致线程阻塞，从而降低性能。特别是在多读场景下，悲观锁可能引入大量的额外并发开销，因为每个读操作都需要获得独占锁。

相比之下，StampedLock 的乐观锁思想更适合多读场景。乐观锁假定数据操作不存在并发冲突，因此不会引起锁竞争，也不会导致线程阻塞和死锁。乐观锁通常在提交修改时才验证资源是否被其他线程修改。不过在多写场景下乐观锁会频繁失败和重试，这同样会对性能造成一定影响。

1.1.1 synchronized

synchronized 是 Java 中用于实现线程同步的关键字，它主要用于创建同步代码块或同步方法，以确保在多线程环境下对共享资源的访问是安全的。通过使用 synchronized 可以避免多个线程同时访问共享资源而引发的并发问题，如竞态条件和数据不一致等。

1.1.1.1 同步代码块

通过在代码块内使用 synchronized 关键字来创建同步代码块，它可以用来保护代码块，确保在同一时刻只有一个线程能够进入同步代码块。一个典型的用法是将需要同步的代码放在同步代码块中，并指定一个锁对象作为同步的依据。

虽然任意一个唯一的对象（比如一个字符串）都可以作为同步代码块的锁对象，但锁的粒度过大会导致并发安全问题，粒度过小会导致性能下降。类比同步方法，一般情况下，对于实例方法，通常使用 this 作为锁对象，对于静态方法，通常使用类的字节码对象类名.class 作为锁对象。

同步代码块的基本使用示例：

    private static int counter;
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Runnable incrementTask = () -> {
            for (int i = 0; i < 10000; i++) {
                // 同步代码块
                synchronized (lock) {
                    counter++;
                }
            }
        };

        Thread thread1 = new Thread(incrementTask);
        Thread thread2 = new Thread(incrementTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final counter value: " + counter);
    }

此外，在同步代码块中还可以通过 wait() 方法让当前线程进入等待状态，直到其他线程调用相同对象的 notify() 或 notifyAll() 方法来唤醒它。这三个方法的实现也同样依赖于 monitor 机制，因此需要被绑定到指定的锁对象上。

wait() 和 notify() 的基本使用示例：

    public static void main(String[] args) {
        final Object lock = new Object();

        // 等待线程
        Thread waiter = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Waiter: Waiting for a notification...");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Waiter: Got a notification!");
            }
        });

        // 通知线程
        Thread notifier = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Notifier: Performing some work...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Notifier: Work done, notifying the waiter...");
                lock.notify();
            }
        });

        waiter.start();
        notifier.start();
    }

在这里插入图片描述

1.1.1.2 同步方法

通过在方法定义处使用 synchronized 关键字来创建同步方法，它可以将整个方法体都变成一个同步代码块。同步方法底层通过隐式锁对象实现，只是锁的范围是整个方法代码。如果方法是实例方法，同步方法默认用 this 作为的锁对象。如果方法是静态方法，同步方法默认用类名.class 作为的锁对象。

同步方法的优点是简单，可以很方便地实现线程同步。不过锁的范围较大，可能影响性能，因为其他不需要同步的代码也会被锁住。

同步方法的基本使用示例：

public class Test {
    private static int counter;

    public static synchronized void increment() {
        for (int i = 0; i < 10000; i++) {
            counter++;
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(Test::increment);
        Thread thread2 = new Thread(Test::increment);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final counter value: " + counter);
    }
}

1.1.2 ReentrantLock

ReentrantLock 是 Java 提供的一个可重入锁，默认为非公平锁，它相比于使用 synchronized 关键字具有更大的灵活性。通过 ReentrantLock，你可以显式地获取锁和释放锁，从而精确地控制同步范围。

ReentrantLock 提供了更多的功能，比如可重入性、可定时的锁等待、公平性设置等。但需要注意，使用 ReentrantLock 需要手动释放锁，因此务必在 finally 块中释放锁，以防止死锁情况的发生。

ReentrantLock 的基本使用示例：

public class Test {
    private static final Lock lock = new ReentrantLock();
    private static int counter;

    public static void main(String[] args) {
        Runnable incrementTask = () -> {
            for (int i = 0; i < 10000; i++) {
                lock.lock();
                try {
                    counter++;
                    System.out.println(Thread.currentThread().getName());
                } finally {
                    // 放在finally块中保证锁一定能被释放
                    lock.unlock();
                }
            }
        };

        Thread thread1 = new Thread(incrementTask);
        Thread thread2 = new Thread(incrementTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final counter value: " + counter);
    }
}

1.1.3 StampedLock

StampedLock 是 Java 提供的一个支持乐观读、悲观读和写操作的锁机制。它在 Java 8 中引入，通过使用乐观读锁来提供更高的并发性，同时支持升级为悲观读锁或写锁。不过它不可重入且不支持条件变量 Conditon。

StampedLock 提供了三种读写控制模式：

乐观读锁：乐观读锁是一种无锁操作，它假设没有写操作会发生。线程可以直接读取数据而无需获取锁，读取完成后通过校验版本信息来判断数据是否有效。如果数据有效，操作成功；如果数据无效，需要尝试其他方式来获取锁。乐观读锁适用于读多写少的场景。
悲观读锁：悲观读锁是常规的读锁，它会阻塞写操作，但不会阻塞其他读操作。悲观读锁适用于读多写多的场景，可以保证读操作之间的数据一致性。
写锁：写锁会阻塞其他的读操作和写操作，用于保护共享资源的写操作。

StampedLock 的基本使用示例：

public class Main {
    private static final StampedLock lock = new StampedLock();
    private static int counter;

    public static void main(String[] args) {
        Runnable incrementTask = () -> {
            for (int i = 0; i < 10000; i++) {
                long stamp = lock.writeLock(); // 获取写锁
                try {
                    counter++;
                } finally {
                    lock.unlockWrite(stamp); // 释放写锁
                }
            }
        };

        Thread thread1 = new Thread(incrementTask);
        Thread thread2 = new Thread(incrementTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final counter value: " + counter);
    }
}

1.2 原子变量

除了 StampedLock 中的乐观读锁，java.util.concurrent.atomic 包下面 AtomicInteger、AtomicLong、AtomicIntegerArray、AtomicReference 等原子变量类也是基于乐观锁的思想实现的。

不过普通的 AtomicInteger 可能会存在 ABA 问题，此时可以使用 AtomicStampedReference，它内部除了一个对象引用，还维护了一个可以自动更新的整数，通过标识版本来避免 ABA 问题。

AtomicInteger 的基本使用示例：

import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    private static final AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        Runnable incrementTask = () -> {
            for (int i = 0; i < 10000; i++) {
                counter.incrementAndGet();
            }
        };

        Thread thread1 = new Thread(incrementTask);
        Thread thread2 = new Thread(incrementTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final counter value: " + counter.get());
    }
}

AtomicReference 的基本使用示例：

import java.util.concurrent.atomic.AtomicReference;

public class Main {
    private static final AtomicReference<Integer> counterRef = new AtomicReference<>(0);

    public static void main(String[] args) {
        Runnable incrementTask = () -> {
            for (int i = 0; i < 10000; i++) {
                while (true) {
                    Integer current = counterRef.get();
                    Integer updated = current + 1;
                    if (counterRef.compareAndSet(current, updated)) {
                        break;
                    }
                }
            }
        };

        Thread thread1 = new Thread(incrementTask);
        Thread thread2 = new Thread(incrementTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final counter value: " + counterRef.get());
    }
}

1.3 ThreadLocal

ThreadLocal的作用是提供线程内的局部变量,在多线程环境下访问时能保证各个线程内的ThreadLocal变量各自独立。它的主要作用是在多线程环境下为每个线程提供一个独立的变量副本，使得每个线程在访问 ThreadLocal 时获取到的都是自己的私有变量，而不是共享的同一个变量。换句话说，ThreadLocal 能够隔离线程间的数据共享，提供线程级别的数据存储。

主要用于实例需要在多个方法中共享，但不希望被多线程共享的场景中.

Thread Local的方法：

初始化/设置值： ThreadLocal.set(T value) 方法用来设置当前线程的变量副本值。
获取值： T get() 方法用来获取当前线程所对应的变量副本的值，如果此线程从未设置过值，那么返回 null 或者初始值（如果有的话）。
移除值： remove() 方法用于删除当前线程保存的变量副本，如果不主动清理，可能会造成内存泄露。

ThreadLocal使用注意点:

初始化线程中对象，防止空指针异常，方便设置对象属性值，因为它默认是返回的空；
不能用来存储大的对象
使用private static final进行修饰，防止多实例时内存泄漏的问题
分布式环境不能用ThreadLocal直接传递参数，因为不是同一个JVM；

使用时需要注意的问题:

内存泄露： 当线程结束生命周期后，如果没有显式调用 remove() 方法，存储在线程本地变量表中的 ThreadLocal 变量副本不会自动删除，这可能导致它们无法被垃圾回收，尤其是在线程池场景中，如果线程会被复用，这个问题更为突出。
线程安全的误解： 虽然 ThreadLocal 保证了每个线程只能访问自己的变量副本，但是它并不能保证变量副本本身的线程安全性，即如果存放在 ThreadLocal 中的对象不是线程安全的，多个线程通过各自的 ThreadLocal 访问相同的非线程安全对象时，还需要采取额外的同步措施。
过度使用： 不恰当的使用 ThreadLocal 可能导致代码逻辑变得复杂，增加维护难度，尤其是当线程间本来就需要共享数据时，不应该滥用 ThreadLocal 避免数据交换。

使用中可能出现的事故:

内存泄露： 当线程结束生命周期后，如果没有显式调用 remove() 方法，存储在线程本地变量表中的 ThreadLocal 变量副本不会自动删除，这可能导致它们无法被垃圾回收，尤其是在线程池场景中，如果线程会被复用，这个问题更为突出。
线程安全的误解： 虽然 ThreadLocal 保证了每个线程只能访问自己的变量副本，但是它并不能保证变量副本本身的线程安全性，即如果存放在 ThreadLocal 中的对象不是线程安全的，多个线程通过各自的 ThreadLocal 访问相同的非线程安全对象时，还需要采取额外的同步措施。
过度使用： 不恰当的使用 ThreadLocal 可能导致代码逻辑变得复杂，增加维护难度，尤其是当线程间本来就需要共享数据时，不应该滥用 ThreadLocal 避免数据交换。

1.3.1 简单使用

    public static void main(String[] args) {
        // 创建两个线程并启动
        new Thread(() -> {
            // 设置当前线程的ThreadLocal变量
            threadLocal.set("Thread A");
            System.out.println("In Thread A: " + threadLocal.get());
        }).start();

        new Thread(() -> {
            // 设置当前线程的ThreadLocal变量，不影响其他线程
            threadLocal.set("Thread B");
            System.out.println("In Thread B: " + threadLocal.get());

            // 清理本线程的ThreadLocal变量
            threadLocal.remove();
            // 此时尝试获取已经移除的ThreadLocal变量，应该返回null
            System.out.println("After remove in Thread B: " + threadLocal.get());
        }).start();

        // 注意：主线程直接调用get()会报空指针异常，因为它没有设置过任何值
        // System.out.println("In Main Thread: " + threadLocal.get()); // 这行代码应避免运行，否则可能抛出NullPointerException

    }

示例解释：

我们首先创建了一个 ThreadLocal 类型的静态变量 threadLocal。
在每个线程内部，我们使用 set(String value) 方法给当前线程设置了一个本地变量的值。
同样在每个线程内部，我们使用 get() 方法来获取当前线程关联的本地变量的值。注意，每个线程只能获取到自己设置的那个值，相互之间不会干扰。
在第二个线程里展示了如何使用 remove() 方法清除当前线程的 ThreadLocal 变量。

1.3.2 复杂使用

场景： 我们模拟同时有100个人发起请求访问某接口，然后输出100次租户id和租户name，即100个线程做同一件事情。事先分析：每个租户都有自己的id和名称，各自独立。最后我们输出租户id和租户名,为了方便演示我们租户名用“杨+线程id”表示。

1.首先我们定义一个租户Tenant 对象

import com.alibaba.fastjson.JSONObject;
import lombok.Data;

@Data
public class Tenant {

    private String tenantId;

    private String tenantName;

    @Override
    public String toString () {
        return JSONObject.toJSONString(this);
    }
}

2 创建一个全局ThreadLocal租户对象，并对租户进行初始化；

public class TenantContext {

    // 初始化线程中对象，防止空指针异常，方便设置对象属性值，因为它默认是返回的空；
    // 不能用来存储大的对象
    // 使用private static final进行修饰，防止多实例时内存泄漏的问题
    // 分布式环境不能用ThreadLocal直接传递参数，因为不是同一个JVM；
    private static final ThreadLocal<Tenant> threadLocal = new ThreadLocal<Tenant>(){
        
        // 此处一定要对租户初始化实例对象，否则会报空指针异常，默认返回的空。
        @Override
        protected Tenant initialValue() {
            return new Tenant();
        }
    };

    // 定义获取线程中租户静态方法
    public static Tenant getTenant(){
        return threadLocal.get();
    }

    // 定义移除线程中的租户静态方法
    public static void removeValue(Object key){
        Tenant tenant = threadLocal.get();
        if(null != tenant){
            threadLocal.remove();
        }
    }
}

3 模拟具体的业务操作：给租户设置tenantId和设置tenantName


/**
 * @Description: 为上下文中取出的租户设置tenantId和tenantName
 */
public class TenantIdAction {
    // 从上下问获取租户对象，并给租户对象设置id值；id为当前线程的id；
    public void setTenantId(){
        Tenant tenant = TenantContext.getTenant();
        tenant.setTenantId(this.getTenantId());
    }

    // 用"租户-线程id"来拼接租户名称
    public void setTenantName(){
        Tenant tenant = TenantContext.getTenant();
        String name = "杨" + tenant.getTenantId();
        tenant.setTenantName(name);
    }

    // 获取线程id作为租户id
    public String getTenantId(){
        return String.valueOf(Thread.currentThread().getId());
    }
}

4 模拟前端的访问请求，我们定义线程具体执行逻辑

/** 
 * @Description: 模拟前端发送请求，进行参数的预封装；
 */
public class HtmlRequest implements Runnable {

    private TenantIdAction tenantIdAction = new TenantIdAction();

    @Override
    public void run() {
        // 上下文获取租户对象，此时租户对象为初始化对象，属性均为null；
        Tenant tenant = TenantContext.getTenant();

        // 模拟前端准备发送请求：开始设置租户的id
        tenantIdAction.setTenantId();
        tenantIdAction.setTenantName();
        System.out.println("tenantId:"+tenant.getTenantId()+"  --- "+tenant.getTenantName());

        // 每个线程设置完属性以后，要清除掉上下文中的对象，是Tenant实例重新回到初始化状态；
        // 可以保证每个线程取到的上下文里的初始对象都是一样的；
        TenantContext.removeValue(tenant);

        // 因为上一行的已经清空了上下文中的租户对象，所以下面这行代码打印的租户id和name应该都是null；需要看执行效果的同学放开下面代码注释即可。
//        System.out.println("remove----tenantId : "+ TenantContext.getTenant().getTenantId() +"name : "+ TenantContext.getTenant().getTenantName());
    }
}

5 最后main方法进行测试

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

public class TestTenant {
    public static void main(String[] args) {
        HtmlRequest htmlRequest = new HtmlRequest();

        // 新创建线程，线程id不会出现重复，都是新创建的
        for(int i = 1; i <= 100; i++){
            new Thread(htmlRequest).start();
        }
    }
}

另一版参考ThreadLocal来存储用户的登录信息
区别：


// 创建一个ThreadLocal来存放CurrentUserInfo
public class UserContext {
    private static final ThreadLocal<CurrentUser> currentUserThreadLocal = new ThreadLocal<>();
 
    public static void setCurrentUser(CurrentUser user) {
        currentUserThreadLocal.set(user);
    }
 
    public static CurrentUser getCurrentUser() {
        return currentUserThreadLocal.get();
    }
 
    public static void clearCurrentUser() {
        currentUserThreadLocal.remove();
    }
}


/ 在登录验证成功后，我们会在登录拦截器或者登录成功的处理逻辑中设置当前用户的上下文：
// 登录成功后设置ThreadLocal
public class LoginInterceptor implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
 
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 假设 authenticate(...) 方法完成了验证并返回了登录用户对象
        CurrentUser loggedInUser = authenticate(httpServletRequest);
 
        if (loggedInUser != null) {
            UserContext.setCurrentUser(loggedInUser);
        }
 
        try {
            chain.doFilter(request, response);
        } finally {
            // 请求处理完毕后清理ThreadLocal，防止内存泄漏
            UserContext.clearCurrentUser();
        }
    }
}    
   
// 在需要用户上下文的地方，可以直接从ThreadLocal中获取：
public class UserService {
    public void processUserData() {
        CurrentUser currentUser = UserContext.getCurrentUser();
        if (currentUser != null) {
            // 处理当前登录用户的数据...
        }
    }
}

1.4 CountDownLatch

CountDownLatch 是一个同步辅助类，它允许一个或多个线程等待其他线程完成操作。CountDownLatch 通过一个计数器来实现一个线程等待其他线程完成某个操作，当计数器的值减为零时，等待的线程被释放。

CountDownLatch 主要提供了以下方法：

CountDownLatch(int count)：构造方法，用于初始化计数器，指定计数器的初始值为 count。
void await() throws InterruptedException：当调用线程调用此方法时，它会一直等待，直到计数器减为零。如果计数器不为零，线程将被阻塞。
boolean await(long timeout, TimeUnit unit) throws InterruptedException：在指定的时间内等待计数器减为零，如果在指定时间内计数器未减至零，线程将被唤醒。
void countDown()：每个被等待的线程执行完任务后，都应该调用此方法来减小计数器的值。

以下是一个 CountDownLatch 的简单的示例：

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

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(10);
        CountDownLatch latch = new CountDownLatch(10);

        Runnable task = () -> {
            System.out.println("task");
            latch.countDown();
        };

        long begin = System.currentTimeMillis();

        for (int i = 0; i < 10; i++) {
            es.submit(task);
        }
        latch.await();

        long end = System.currentTimeMillis();
        System.out.println("time = " + (end - begin));
    }
}

1.5 Future 和 CompletableFuture

Future 是一个接口，允许我们提交一个任务给线程池或其他异步执行机制，并且在未来获取该任务的结果。它通常用于处理耗时的操作，以便不阻塞主线程，从而提高程序的性能和响应性。

Future 接口相关方法：

get()：用来获取异步任务的结果，如果任务尚未完成，调用 get() 将会阻塞当前线程，直到任务完成并返回结果。
isDone()：用来检查异步任务是否已经完成，如果任务已经完成，它将返回 true，否则返回 false。
cancel(boolean mayInterruptIfRunning)：用于取消异步任务的执行，mayInterruptIfRunning 参数用于指定是否应该中断正在执行的任务。如果任务成功取消，get() 方法将会抛出 CancellationException。

Future 接口通常通过 ExecutorService 接口的实现来使用，ExecutorService 提供了一种提交任务并获取 Future 的方式，从而管理线程池中的任务。

此外，Java 8 中还引入了 CompletableFuture 类，它实现了 Future 接口并提供了更丰富的功能，包括支持函数式编程、组合多个异步任务等。

Future 异步执行任务示例：

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

class Solution {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        Future<Integer> future = executor.submit(() -> {
            Thread.sleep(2000);  // 模拟一个耗时操作
            return 42;
        });

        try {
            System.out.println("等待任务完成...");
            Integer result = future.get();
            System.out.println("任务完成，结果为：" + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        executor.shutdown();
    }
}

CompletableFuture 异步执行任务示例：
分批处理数据

批量删除数据

@Async("commonCmdbExecutor")
public CompletableFuture<CmdbResultVo> multiDeleteObjInstance(CmdbDeleteObjInstanceReqVo body,
    CountDownLatch latch) {
    String url = cmdbHost + CmdbConstants.MULTI_DELETE_OBJ_INSTANCE_URL;
    ResponseEntity<CmdbResultVo> exchange = null;
    try {
        exchange = restTemplate.exchange(url, HttpMethod.POST, new HttpEntity<Object>(body, new HttpHeaders()),
            CmdbResultVo.class);
    } catch (Exception e) {
        LOG.error("delete data error", e);
    } finally {
        latch.countDown();
    }
    return exchange == null ? null : CompletableFuture.completedFuture(exchange.getBody());
}


public int deleteCmdbDataAsync(String objCode, List<String> ids) {
    int groupQty = ids.size() / DELETE_MAX_SIZE;
    int resultCode = 1;
    CountDownLatch latch = new CountDownLatch(groupQty + 1);
    List<CompletableFuture<CmdbResultVo>> futures = new CopyOnWriteArrayList<>();
    for (int i = 0; i <= groupQty; i++) {
        CmdbDeleteObjInstanceReqVo deleteBody = new CmdbDeleteObjInstanceReqVo();
        deleteBody.setObjCode(objCode);
        List<String> curGroup = getCurGroup(i, DELETE_MAX_SIZE, ids);
        deleteBody.setInstanceIdList(curGroup);
        CompletableFuture<CmdbResultVo> cmdbResultVoCompletableFuture =
            cmdbClient.multiDeleteObjInstance(deleteBody, latch);
        futures.add(cmdbResultVoCompletableFuture);
    }
    try {
        latch.await(3, TimeUnit.MINUTES);
    } catch (InterruptedException e) {
        LOG.error("InterruptedException:", e);
        Thread.currentThread().interrupt();
    } catch (Exception e) {
        LOG.error("Exception:", e);
    }
    for (CompletableFuture<CmdbResultVo> future : futures) {
        try {
            CmdbResultVo response = future.get();
            if (response.getResultCode() == 0) {
                resultCode = 0;
            }
        } catch (Exception e) {
            LOG.error("Exception:", e);
        }
    }
    return resultCode;
}

批量更新数据

    @Async("commonCmdbExecutor")
    public <T> CompletableFuture<CmdbResultVo> multiUpdateObjInstanceAsync(CmdbUpdateObjInstanceReqVo<T> body,
        CountDownLatch latch) {
        String url = cmdbHost + CmdbConstants.MULTI_UPDATE_OBJ_INSTANCE_URL;
        ResponseEntity<CmdbResultVo> exchange = null;
        try {
            exchange = restTemplate.exchange(url, HttpMethod.POST, new HttpEntity<Object>(body, new HttpHeaders()),
                CmdbResultVo.class);
        } catch (Exception e) {
            LOG.error("update data error", e);
        } finally {
            latch.countDown();
        }
        return exchange == null ? null : CompletableFuture.completedFuture(exchange.getBody());

    }

1.6 volatile

volatile 关键字主要有两层语义：

保证多线程环境下共享变量操作的可见性：参考 Java 内存模型（JMM）中先行发生（Happens-Before）原则对 volatile 变量规则的描述，对于一个 volatile 变量，如果对于这个变量的写操作先行发生于这个变量的读操作，那么这个写操作所产的影响对于后续的读操作是可见的。
禁止指令重排序：编译器在编译时会在生成的字节码中插入特定的内存屏障指令，确保在 volatile 变量读写操作前后的代码不会被重排序。具体来说，会在 volatile 变量写操作之后，读操作之前插入屏障，因此执行到 volatile 变量读写操作时，前面的操作一定已经执行完成，后面的操作一定还未开始。
voliatile有三大特性：

保证可见性。
不保证原子性。
禁止指令重排。

因此，voliatile解决不了线程安全问题

2 线程池

2.1 ThreadPoolExecutor

Java 中的线程池接口为 ExecutorService，一个常用的实现类为 ThreadPoolExecutor，其构造函数为：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
                   long keepAliveTime, TimeUnit unit,
                   BlockingQueue<Runnable> workQueue,
                   ThreadFactory threadFactory,
                   RejectedExecutionHandler handler)

参数说明：

corePoolSize：线程池的核心线程数，即任务队列未达到队列容量时，最大可以同时运行的线程数量。即使线程是空闲的，它们也不会被销毁，除非线程池被关闭。
maximumPoolSize：线程池的最大线程数。在没有核心线程空闲的情况下，如果任务数量增加，线程池可以扩展到最大线程数。如果任务数量继续增加，超过线程池最大大小的任务将会被拒绝执行。
keepAliveTime：非核心线程的最大空闲时间。当线程池中的线程数量超过 corePoolSize，多余的非核心线程会在空闲时间超过 - keepAliveTime 后被销毁，以减少资源占用。
unit：时间单位，用于指定 keepAliveTime 的时间单位。
workQueue：用于存储等待执行的任务的阻塞队列。当所有核心线程都忙碌时，新任务将被放入队列等待执行。常用的队列类型包括 - LinkedBlockingQueue（最大长度为 Integer.MAX_VALE，即无界队列）、ArrayBlockingQueue（有界队列）、PriorityBlockingQueue（基于堆的优先级队列）等。
threadFactory：用于创建线程的工厂。可以通过提供自己实现的 ThreadFactory 自定义线程的创建过程。
handler：拒绝策略，用于处理无法提交给线程池执行的任务。当任务数量超过线程池最大大小且队列已满时，将使用拒绝策略处理任务。

新任务拒绝策略：

ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出 RejectedExecutionException 异常，是默认的策略
ThreadPoolExecutor.DiscardPolicy	丢弃任务，但是不抛出异常，这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务，然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用任务的 run() 方法从而绕过线程池直接执行

注意事项：

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。

常用方法：

方法名称	说明
void execute(Runnable command)	执行 Runnable 任务
Future submit(Callable task)	执行 Callable 任务，返回一个 Future 对象，用于获取线程返回的结果
void shutdown()	等全部任务执行完毕后，再关闭线程池
List shutdownNow()	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

ThreadPoolExecutor 的基本使用示例：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.printf("[%s] %s\n", Thread.currentThread().getName(),
                          LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService pool = new ThreadPoolExecutor(2, 3,
                                                      8, TimeUnit.SECONDS,
                                                      new ArrayBlockingQueue<>(2),
                                                      Executors.defaultThreadFactory(),
                                                      new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();

        pool.execute(target); // 核心线程
        pool.execute(target); // 核心线程
        pool.execute(target); // 任务队列等待
        pool.execute(target); // 任务队列等待
        pool.execute(target); // 任务队列满，启动一个临时线程
        pool.execute(target); // 核心线程和临时线程忙，同时任务队列已满，拒绝任务

        pool.shutdown();
    }
}

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task atreus.ink.MyRunnable@7a0ac6e3 rejected from java.util.concurrent.ThreadPoolExecutor@71be98f5[Running, pool size = 3, active threads = 3, queued tasks = 2, completed tasks = 0]
	at java.base/java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2055)
	at java.base/java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:825)
	at java.base/java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1355)
	at atreus.ink.Main.main(Main.java:20)
[pool-1-thread-2] 2023-08-30 15:57:44
[pool-1-thread-1] 2023-08-30 15:57:44
[pool-1-thread-3] 2023-08-30 15:57:44
[pool-1-thread-1] 2023-08-30 15:57:47
[pool-1-thread-2] 2023-08-30 15:57:47

使用 submit() 以捕获异常：

public class ThreadPoolExceptionHandling {

    @SuppressWarnings("all")
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(1);

        Future<Integer> future = executorService.submit(() -> {
            throw new RuntimeException("Exception in task");
        });

        try {
            // 调用 get() 方法获取任务执行结果，如果任务抛出了异常，这里会抛出 ExecutionException
            Integer result = future.get();
            System.out.println("Task result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            // 处理任务执行中抛出的异常
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}

使用案例：

    private static void asyncHandleInputStream(Process proc) {
        ExecutorService asyncHandleInputStream = null;
        try {
            asyncHandleInputStream = new ThreadPoolExecutor(5, 10, 60, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
            asyncHandleInputStream.execute(() -> {
                String inputInfoLine;
                try (BufferedReader inputReader = new BufferedReader(
                    new InputStreamReader(proc.getInputStream(), StandardCharsets.UTF_8))) {
                    while ((inputInfoLine = inputReader.readLine()) != null) {
                    }
                } catch (Exception exp) {
                    LOGGER.error("handle InputStream error! {}", exp);
                }
            });
        } finally {
            if (asyncHandleInputStream != null) {
                asyncHandleInputStream.shutdown();
            }
        }
    }

java.util.concurrent.ExecutionException: java.lang.RuntimeException: Exception in task
	at java.util.concurrent.FutureTask.report(FutureTask.java:122)
	at java.util.concurrent.FutureTask.get(FutureTask.java:192)
	at ThreadPoolExceptionHandling.main(ThreadPoolExceptionHandling.java:16)
Caused by: java.lang.RuntimeException: Exception in task
	at ThreadPoolExceptionHandling.lambda$main$0(ThreadPoolExceptionHandling.java:10)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:750)

2.2 Executors

Executors 是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。

方法名称	说明
public static ExecutorService newFixedThreadPool(int nThreads)	创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它
public static ExecutorService newSingleThreadExecutor()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程
public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了 60s 则会被回收掉。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务或者定期执行任务

newScheduledThreadPool 的基本使用示例：

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.printf("[%s] %s\n", Thread.currentThread().getName(),
                          LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
    }
}

package atreus.ink;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
        Runnable target = new MyRunnable();

        // 延迟1秒后执行target任务
        pool.schedule(target, 1, TimeUnit.SECONDS);

        // 延迟2秒后，每隔3秒执行一次target任务
        pool.scheduleAtFixedRate(target, 2, 3, TimeUnit.SECONDS);

        Thread.sleep(10 * 1000);
        pool.shutdown();
    }
}

[pool-1-thread-1] 2023-08-30 16:26:33
[pool-1-thread-2] 2023-08-30 16:26:34
[pool-1-thread-2] 2023-08-30 16:26:37
[pool-1-thread-2] 2023-08-30 16:26:40

3 线程状态

请添加图片描述
java.lang.Thread.State 中定义了六种线程状态，可以通过 getState() 方法获取当前线程的状态。

线程状态	说明
NEW	通过 new 关键字新建一个线程，但还未调用 start() 方法
RUNNABLE	调用 start() 后等待调度（就绪）、正在运行
BLOCKED	等待 synchronized 监视器锁时，陷入阻塞状态
WAITING	等待其他线程执行特定的操作
TIMED_WAITING	具有指定等待时间的等待状态
TERMINATED	线程完成执行，变为终止状态

sleep() 和 yield() 的区别：

sleep() 会强制线程进入超时等待状态，时间到了之后才会转入就绪状态，是一种相对确定的暂停方式。而 yield() 方法会提示当前线程进入就绪状态，只是一种提示性的暂停，有可能被操作系统忽略。
使用 sleep() 方法需要处理中断异常，而 yield() 不用。

BLOCKED 和 WAITING 均属于线程的阻塞等待状态，区别如下：

BLOCKED 是 synchronized 锁竞争失败后被动触发的状态，WAITING 是人为主动触发的状态。
BLOCKED 的唤醒时自动触发的，而 WAITING 状态是必须要通过特定的方法来主动唤醒，比如 Object.notify() 方法可以唤醒 Object.wait() 方法阻塞的线程，LockSupport.unpark() 可以唤醒 LockSupport.park() 方法阻塞的线程。