5分钟搞懂JMM:10倍优化Java并发性能!

Java并发编程核心详解:线程、锁、JMM与线程池实战 在Java后端开发中,并发编程是绕不开的核心技能,也是面试与线上问题排查的高频考点。它主要解决多线程环境下的原子性、可见性与有序性三大问题,具体实现依赖线程、锁、内存模型等基础机制。synchronized与volatile分别从互斥与内存屏障角度保证线程安全,而JMM(Java内存模型)与happens-before原则则定义了变量在并发访问时的可见性规则。进一步地,JUC中的锁、CAS、并发容器以及线程池,为复杂业务场景提供了高效且可控的并发工具。理解线程池的参数配置与拒绝策略,能够有效规避资源耗尽风险 阅读详情

引言

在现代软件开发中,多线程并发编程已成为提高程序性能和资源利用率的关键技术。Java作为一种广泛使用的编程语言,提供了丰富的并发编程工具和框架。然而,要编写正确、高效且线程安全的并发程序,深入理解Java内存模型(JMM)是必不可少的。

Java内存模型(JMM) 是Java并发编程的核心概念之一,它定义了Java程序中变量的访问规则,以及这些变量如何与主内存(Java堆)进行交互。JMM不仅规定了线程之间共享变量的读写操作,还涵盖了这些操作的可见性、原子性和有序性。简而言之,JMM是一组规则,它确保了在多线程环境下,程序的行为是可预测和一致的。

JMM的重要性不仅体现在它对程序正确性的影响上,还体现在它对程序性能的潜在影响。正确理解和应用JMM可以帮助开发者避免常见的并发问题,如竞态条件和死锁,同时也能够优化程序性能,减少不必要的同步开销。

在本文中,我们将深入探讨JMM的工作原理,包括它的三大特性:原子性、可见性和有序性。我们将分析这些特性如何影响并发编程,并提供实际的代码示例来说明这些概念。此外,我们还将讨论JMM与指令重排序的关系,以及如何通过happens-before规则来保证程序的正确性。

通过本文的学习,读者将能够更好地理解JMM的复杂性,并掌握在实际编程中应用JMM的最佳实践。这不仅有助于提高代码质量,还能提升程序的性能和可靠性。

JMM的基本概念

Java内存模型(JMM)是一个抽象的概念,它描述了一组规则,这些规则定义了程序中变量的访问方式。在JMM的框架下,所有的变量都存储在主内存中,而每个线程拥有自己的工作内存,用于存储该线程使用的变量的拷贝。

定义JMM

JMM定义了线程和主内存之间的抽象关系,以及对共享变量的访问规则。它确保了在多线程访问共享变量时,即使在没有同步的情况下,也能保持一致的内存访问顺序。

主内存与工作内存

在JMM中,主内存(Main Memory)是所有线程共享的内存区域,用于存储所有线程共享的变量。而每个线程都有自己的工作内存(Working Memory),用于存储该线程私有的数据和对共享变量的拷贝。

  • 主内存:主内存是Java堆中存储所有对象和变量的地方。它是所有线程默认的交互场所,任何线程对变量的修改都必须先在主内存中进行。

  • 工作内存:工作内存是每个线程独有的数据区域,用于存储该线程中的变量。线程对变量的所有操作(读取、赋值)都必须在工作内存中进行,而不能直接读写主内存中的变量。

内存交互操作

JMM规定了主内存和工作内存之间变量的交互操作,包括:

  • read:从主内存中读取一个变量值到工作内存。
  • load:将read操作读取的值放入工作内存的变量副本中,以便之后使用。
  • assign:将一个值赋给工作内存中的变量。
  • use:将工作内存中的一个变量值传递给执行引擎。
  • store:将一个变量值从工作内存传输到主内存。
  • write:将store操作的值写入主内存的变量中。

这些操作确保了在多线程环境中,变量的修改能够被其他线程正确地观察到,从而维护了内存的一致性。

主内存与工作内存

在Java内存模型中,主内存和工作内存的概念是理解并发编程的关键。它们定义了线程如何与内存交互,以及如何保证在多线程环境下数据的一致性和可见性。

主内存的角色和功能

主内存是Java虚拟机(JVM)中所有线程共享的内存区域。它存储了所有的静态字段、数组和对象,以及这些对象的实例字段和类信息。主内存的主要功能包括:

  • 数据共享:所有线程都可以通过主内存来共享数据。
  • 变量存储:主内存中存储了所有线程共享的变量。
  • 线程间通信:线程通过主内存来交换信息,例如,一个线程修改了主内存中的变量,其他线程可以通过读取主内存来获取这个变量的最新值。

工作内存的机制

每个线程都有自己的工作内存,它是该线程私有的数据区域。工作内存的主要功能包括:

  • 数据缓存:线程可以将主内存中的数据复制到工作内存中,以便快速访问。
  • 变量操作:线程对变量的所有操作(如读取、赋值)都必须在工作内存中进行。
  • 减少竞争:通过在工作内存中进行操作,减少了对主内存的直接访问,从而降低了线程间的竞争。

线程的私有性

工作内存的私有性意味着每个线程只能访问自己的工作内存,而不能直接访问其他线程的工作内存。这种设计有助于:

  • 隔离性:每个线程的操作不会直接影响到其他线程。
  • 安全性:防止多个线程同时修改同一个变量,从而避免数据不一致的问题。
  • 性能优化:通过减少对共享资源的访问,提高程序的执行效率。

示例:主内存与工作内存的交互

public class SharedVariable {
    public static int number = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            number = 1; // 线程t1将number的值设置为1
        });

        Thread t2 = new Thread(() -> {
            if (number == 1) {
                System.out.println("Number is 1"); // 线程t2检查number的值
            }
        });

        t1.start();
        t2.start();
    }
}

在这个示例中,number变量存储在主内存中。线程t1修改了number的值,而线程t2读取了number的值。这个简单的示例展示了主内存和工作内存之间的交互。

内存交互操作

Java内存模型(JMM)定义了一组操作,这些操作规定了主内存和工作内存之间的交互方式。理解这些操作对于编写正确、高效的并发程序至关重要。

read和load操作

  • read操作:这个操作允许线程从主内存中读取一个变量的值。read操作首先会检查该变量是否被锁定,如果没有被锁定,则将该变量的值从主内存传输到线程的工作内存中。
  • load操作:load操作将read操作读取的值放入工作内存的变量副本中,以便线程之后使用。load操作是将数据从工作内存“移动”到线程的执行引擎中,以便执行引擎可以操作这些数据。

use操作

  • use操作:use操作是指线程使用工作内存中的变量值。在JMM中,use操作必须在load操作之后进行,即线程不能使用尚未从主内存加载的变量值。

assign操作

  • assign操作:assign操作是将一个值赋给工作内存中的变量。这个操作是线程对工作内存中的变量进行修改的第一步。

store和write操作

  • store操作:store操作是将assign操作的值从工作内存传输到主内存。store操作是将数据从线程的工作内存“移动”到主内存中。
  • write操作:write操作是将store操作的值写入主内存的变量中。write操作是将数据最终写入主内存,使得其他线程可以读取到这个更新后的值。

示例:内存交互操作

public class MemoryOperationsExample {
    public static int sharedVar = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            // 线程t1执行assign和store操作
            sharedVar = 10; // assign操作:将10赋值给工作内存中的sharedVar
            // 隐含了store操作:将10从工作内存传输到主内存中的sharedVar
        });

        Thread t2 = new Thread(() -> {
            // 线程t2执行read和load操作
            int value = sharedVar; // read操作:从主内存读取sharedVar的值
            // 隐含了load操作:将读取的值放入工作内存的sharedVar副本中
            System.out.println(value); // use操作:使用工作内存中的sharedVar值
        });

        t1.start();
        t1.join(); // 确保t1线程完成操作
        t2.start();
    }
}

在这个示例中,线程t1首先执行assign操作,将值10赋给工作内存中的sharedVar,然后隐含地执行store操作,将这个值传输到主内存。线程t2执行read操作从主内存读取sharedVar的值,然后隐含地执行load操作,将读取的值放入工作内存的sharedVar副本中,最后执行use操作,使用这个值。

JMM的三大特性

Java内存模型(JMM)通过三大特性来保证并发程序的正确性和性能:原子性(Atomicity)、可见性(Visibility)和有序性(Ordering)。这些特性是JMM的核心,它们定义了多线程环境下内存的访问规则。

原子性(Atomicity)

原子性是指一个操作或者一系列操作要么全部执行并且执行的过程不会被任何其他操作中断,要么就全部都不执行。在Java中,原子操作包括对基本数据类型的赋值和读取操作。

int i = 0; // 原子操作
i = 1;    // 原子操作

对于复合操作(如i++),它们在大多数情况下不是原子的,因为它们包含读取、增加和写入三个步骤。

可见性(Visibility)

可见性是指当一个线程修改了共享变量的值,其他线程能够立即得知这个修改。在Java中,volatile关键字可以保证变量的可见性。

public class VisibilityExample {
    private volatile boolean running = true;

    public void stop() {
        running = false;
    }

    public void test() {
        while (running) {
            // 循环体
        }
    }
}

在这个例子中,如果running变量没有被声明为volatile,那么在stop方法中对running的修改可能不会立即对test方法可见。

有序性(Ordering)

有序性是指在多线程环境中,操作的执行顺序需要遵守一定的规则。Java内存模型允许JVM和编译器对指令进行重排序以优化性能,但在某些情况下,我们需要禁止这种重排序以保证程序的正确性。

public class OrderExample {
    private int a = 0;
    private int b = 0;

    public void writer() {
        a = 1; // 步骤1
        b = 1; // 步骤2
    }

    public void reader() {
        if (a == 1) {
            System.out.println(b); // 步骤3
        }
    }
}

在这个例子中,如果编译器或JVM对writer方法中的步骤1和步骤2进行了重排序,那么reader方法中的步骤3可能会在a被设置为1之前打印出b的值。

JMM与指令重排序

在现代计算机系统中,为了提高执行效率,编译器和处理器常常会对指令进行重排序。这种重排序可能会干扰程序的并发执行,导致意想不到的结果,尤其是在多线程环境中。

什么是指令重排序

指令重排序是指编译器和处理器为了优化性能,可能会改变指令的执行顺序。这包括:

  • 编译器重排序:编译器在代码生成时可能会重新排列代码的执行顺序。
  • 处理器重排序:现代处理器使用流水线、超标量和乱序执行等技术,可能会在执行时改变指令的顺序。

指令重排序的影响

指令重排序可能会导致多线程程序中的数据竞争和内存可见性问题。例如,如果一个线程执行的操作被重排序,那么另一个线程可能看不到这些操作的预期效果。

JMM如何限制重排序

Java内存模型(JMM)通过happens-before规则来限制指令重排序,确保程序的正确性。这些规则定义了操作之间的内存可见性顺序,禁止某些可能会改变程序结果的重排序。

示例:指令重排序的影响

int a = 0, b = 0;
boolean flag = false;

public void writer() {
    a = 1; // 步骤1
    b = 1; // 步骤2
    flag = true; // 步骤3
}

public void reader() {
    if (flag) { // 步骤4
        System.out.println(a + " " + b);
    }
}

在这个例子中,如果编译器或处理器重排序了writer方法中的步骤1和步骤2,或者重排序了步骤2和步骤3,那么reader方法可能在flag被设置为true之前执行步骤4,导致输出不确定的结果。

防止指令重排序

为了防止这种重排序,我们可以使用volatile关键字来确保flag变量的写入对其他线程立即可见,并且不会被重排序。

volatile boolean flag = false;

public void writer() {
    a = 1; // 步骤1
    flag = true; // 步骤3,使用volatile保证可见性和防止重排序
    b = 1; // 步骤2
}

public void reader() {
    if (flag) { // 步骤4
        System.out.println(a + " " + b);
    }
}

通过将flag声明为volatile,我们确保了在writer方法中对flag的写入操作在步骤2和步骤3之后执行,这样reader方法就能看到正确的结果。

Happens-Before规则

在Java内存模型(JMM)中,happens-before原则是一组规则,用于确定一个操作何时对另一个操作可见。这些规则帮助我们理解和控制多线程环境中的内存可见性问题,确保程序的正确性。

什么是happens-before

如果一个操作A happens-before一个操作B,那么A的结果对B可见,且A的执行顺序在B之前。这意味着在A执行完毕后,B才能执行,A对共享变量所做的修改对B可见。

happens-before原则的规则

  1. 程序顺序规则:在一个线程内,按照程序代码顺序,前面的操作happens-before后面的操作。
  2. 监视器锁规则:对一个锁的解锁操作happens-before随后对这个锁的加锁操作。
  3. volatile变量规则:对一个volatile变量的写操作happens-before后续对这个变量的读操作。
  4. 传递性规则:如果操作A happens-before操作B,操作B happens-before操作C,那么操作A happens-before操作C。

示例:happens-before的应用

public class HappensBeforeExample {
    private static volatile boolean flag = false;
    private static int number = 0;

    public static void writer() {
        number = 42; // 步骤1:写入number
        flag = true; // 步骤2:写入flag
    }

    public static void reader() {
        if (flag) { // 步骤3:读取flag
            System.out.println(number); // 步骤4:读取number
        }
    }
}

在这个例子中,我们声明了flag为volatile变量。根据happens-before原则中的volatile变量规则,步骤2(写入flag)happens-before步骤3(读取flag)。由于传递性规则,步骤1(写入number)也happens-before步骤3(读取flag),因此步骤1同样happens-before步骤4(读取number)。这意味着当flag被设置为true时,number的值对reader方法可见。

通过理解和应用happens-before原则,我们可以在多线程环境中控制内存的可见性和操作的顺序,从而编写出正确且高效的并发程序。

JMM的实现与系统内核和CPU

Java内存模型(JMM)是一个抽象的概念,它需要在具体的系统内核和CPU层面上得到实现。这涉及到内存屏障和缓存一致性协议,它们确保了JMM规定的内存访问规则在硬件层面上得到遵守。

内存屏障

内存屏障(Memory Barrier),也称为内存栅栏,是一种CPU指令,用于控制特定类型的处理器重排序,确保CPU在执行后续指令前完成特定操作。内存屏障主要分为以下几类:

  1. Load Barrier:确保所有在屏障之前的读操作完成后,才执行屏障之后的读操作。
  2. Store Barrier:确保所有在屏障之前的写操作完成后,才执行屏障之后的写操作。
  3. Full Barrier:同时具有读屏障和写屏障的功能,确保所有在屏障之前的读写操作完成后,才执行屏障之后的读写操作。

缓存一致性协议

缓存一致性协议(Cache Coherence Protocol)是一组规则,确保多个CPU核心或处理器的缓存中的数据保持一致。这些协议包括:

  • MESI协议:修改(Modified)、独享(Exclusive)、共享(Shared)、无效(Invalid)是MESI协议的四种状态,用于跟踪缓存行的状态。
  • MOESI协议:拥有(Owned)、独享(Exclusive)、共享(Shared)、无效(Invalid)和修改(Modified)是MOESI协议的五种状态,提供了比MESI协议更高效的缓存一致性维护。

JMM与缓存一致性协议

在Java中,volatile关键字和synchronized关键字在底层实现时,会利用缓存一致性协议来保证内存的可见性和原子性。例如,当一个线程写入一个volatile变量时,这个写入操作会通知其他CPU核心或处理器,使它们无效化对应的缓存行,从而确保所有线程看到的是最新的值。

示例:内存屏障的使用

public class MemoryBarrierExample {
    private static long x = 0L;
    private static long y = 0L;

    public static void writer() {
        x = 1L; // 步骤1:写入x
        // 内存屏障,确保x的写入完成
        // 此处在底层可能会插入Store Barrier
        y = 1L; // 步骤2:写入y
    }

    public static void reader() {
        long tempY = y; // 步骤3:读取y
        // 内存屏障,确保y的读取完成后再读取x
        // 此处在底层可能会插入Load Barrier
        long tempX = x; // 步骤4:读取x
        if (tempY == 1L && tempX == 1L) {
            System.out.println("X and Y are both set");
        }
    }
}

在这个例子中,我们通过内存屏障确保了在writer方法中对x和y的写入顺序,以及在reader方法中对y和x的读取顺序。这样可以避免因处理器重排序导致的潜在问题。

理解JMM在系统内核和CPU层面的实现,有助于我们更深入地理解并发编程中的内存可见性和原子性问题。通过内存屏障和缓存一致性协议,JMM确保了多线程程序的正确性和性能。

同步机制

在Java中,线程安全是并发编程的核心问题之一。为了确保多个线程在访问共享资源时不会引发数据不一致的问题,Java提供了多种同步机制,其中最常用的包括synchronized关键字和Lock接口。这些机制在Java内存模型(JMM)中扮演着重要角色,确保了原子性、可见性和有序性。

synchronized关键字

synchronized关键字是Java中最基本的同步机制。它可以用于方法或代码块,确保同一时间只有一个线程可以执行被synchronized修饰的代码。

使用方法
  1. 同步实例方法:锁定当前对象的实例。

public synchronized void instanceMethod() {
    // 同步代码块
}

同步静态方法:锁定类的Class对象。

public static synchronized void staticMethod() {
    // 同步代码块
}

同步代码块:锁定指定对象。

public void method() {
    synchronized (this) {
        // 同步代码块
    }
}

Lock接口

Lock接口是Java 5引入的更灵活的同步机制。与synchronized相比,Lock提供了更高级的功能,如尝试锁定、定时锁定和可中断锁定。

使用方法
  1. 创建Lock实例:

Lock lock = new ReentrantLock();

使用Lock进行同步:

lock.lock(); // 获取锁
try {
    // 保护的代码块
} finally {
    lock.unlock(); // 确保释放锁
}

synchronized与Lock的比较

  • 灵活性:Lock提供了更灵活的锁定机制,可以尝试获取锁、定时锁定等,而synchronized是不可中断的。
  • 性能:在高竞争的情况下,Lock可能比synchronized更高效,因为它可以减少上下文切换的开销。
  • 可重入性:synchronized和Lock都支持可重入锁,但Lock提供了更细粒度的锁控制。

示例:使用synchronized和Lock

public class SynchronizedExample {
    private int count = 0;

    // 使用synchronized关键字
    public synchronized void increment() {
        count++;
    }
}

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

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 确保释放锁
        }
    }
}

在这两个示例中,SynchronizedExample类使用synchronized关键字来确保increment方法的线程安全,而LockExample类使用Lock接口来实现相同的功能。两者都能够确保在多线程环境中对count变量的安全访问。

理解Java中的同步机制是编写线程安全的并发程序的基础。通过合理使用synchronized和Lock,开发者可以确保在多线程环境中共享资源的安全访问,从而避免数据不一致和竞争条件的问题。

并发容器与JMM

Java提供了多种并发容器,它们在Java Collections Framework的基础上进行了扩展,以支持多线程环境。这些容器利用Java内存模型(JMM)的特性来保证线程安全,同时提供比传统同步容器更高的并发性能。

ConcurrentHashMap

ConcurrentHashMap是Java中的一个线程安全HashMap实现。它通过分段锁(Segmentation)和CAS操作来实现高并发访问。

工作原理
  • 分段锁:ConcurrentHashMap将数据分成多个段,每个段有自己的锁。这样,当多个线程访问不同段的数据时,就不会产生锁竞争。
  • CAS操作:ConcurrentHashMap在修改数据时,使用CAS(Compare-And-Swap)操作来保证原子性,这是一种无锁的非阻塞算法。

CopyOnWriteArrayList

CopyOnWriteArrayList是一个线程安全的变体ArrayList,适用于读多写少的场景。

工作原理
  • 写时复制:当有写操作(如添加或删除元素)发生时,CopyOnWriteArrayList会创建当前数组的一个副本,在副本上进行修改,然后将原数组引用指向新数组。
  • 读操作:读操作可以直接在原始数组上进行,因为它们不会改变数组的内容。

示例:使用ConcurrentHashMap

ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();

// 线程安全的put操作
map.put(1, "Item");

// 线程安全的get操作
String value = map.get(1);

在这个示例中,ConcurrentHashMap的put和get操作都是线程安全的,不需要额外的同步措施。

示例:使用CopyOnWriteArrayList

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

// 线程安全的add操作
list.add("Item");

// 线程安全的迭代操作
for (String item : list) {
    System.out.println(item);
}

在这个示例中,CopyOnWriteArrayList的add操作和迭代操作都是线程安全的,适合用于读多写少的场景。

并发容器在JMM框架下通过各种机制实现了线程安全,使得开发者可以更容易地编写高性能的并发程序。理解这些容器的工作原理和适用场景,可以帮助开发者在实际项目中做出正确的选择。

JMM对并发编程的影响

Java内存模型(JMM)对并发编程有着深远的影响。它不仅定义了线程如何正确地共享和修改数据,还对性能优化和程序的正确性有着重要的指导意义。

线程安全

JMM为线程安全提供了理论基础。通过定义主内存和工作内存之间的交互规则,JMM确保了在多线程环境中对共享变量的访问是安全的。开发者必须遵循这些规则来编写线程安全的代码。

性能优化

JMM允许JVM和编译器进行指令重排序以优化性能,但也引入了内存屏障等机制来控制重排序,以保证程序的正确性。理解这些机制可以帮助开发者在不牺牲程序正确性的前提下,优化程序性能。

编程实践

遵循JMM的最佳实践对于编写高质量的并发程序至关重要。以下是一些基于JMM的编程建议:

  1. 慎用volatile:虽然volatile保证了变量的可见性,但它不保证复合操作的原子性。在使用volatile时,需要谨慎考虑是否满足需求。
  2. 合理使用锁:通过synchronized或Lock接口,可以保证多个线程对共享资源的同步访问。合理使用锁可以避免死锁和活锁。
  3. 减少锁的粒度:较大的锁粒度可能导致不必要的性能开销。通过细分锁的范围,可以提高程序的并发性能。
  4. 利用并发容器:Java提供的并发容器,如ConcurrentHashMap和CopyOnWriteArrayList,是为高并发环境设计的。在适合的场景下使用它们,可以简化编程并提高性能。

示例:合理使用锁

import java.util.concurrent.locks.ReentrantLock;

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

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

在这个示例中,我们使用ReentrantLock来保护对共享变量count的访问,确保了线程安全。

JMM是理解和编写Java并发程序的基石。通过深入理解JMM,开发者可以编写出既线程安全又高性能的并发程序。遵循JMM的最佳实践,合理使用同步机制和并发容器,可以帮助我们构建更健壮、更高效的并发应用。

结论

通过本文的深入探讨,我们了解了Java内存模型(JMM)的各个方面,从其定义、核心特性到在并发编程中的实践应用。JMM不仅规定了多线程程序中变量的访问规则,还对性能优化和程序的正确性有着重要的指导意义。

JMM的重要性

  1. 保证线程安全:JMM通过定义原子性、可见性和有序性三大特性,帮助开发者编写出线程安全的代码。
  2. 提高性能:JMM允许适当的指令重排序以提升性能,同时通过内存屏障等机制控制重排序,保证程序的正确执行。
  3. 简化并发编程:JMM配合Java提供的并发容器和同步机制,简化了并发编程的复杂性,使得开发者可以更加专注于业务逻辑。

学习JMM的必要性

在现代多核处理器环境下,JMM的知识变得尤为重要。随着硬件的发展,多线程编程已成为提高程序性能的关键手段。深入理解JMM,可以帮助开发者:

  • 避免常见的并发问题:如竞态条件、死锁等。
  • 优化程序性能:合理利用JMM规则,减少不必要的同步开销。
  • 编写高质量的并发代码:确保代码在多线程环境下的正确性和高效性。

最后的思考

JMM是一个复杂但极其重要的主题。对于任何希望在Java平台上进行高效并发编程的开发者来说,掌握JMM都是一项基本技能。我们鼓励读者继续深入学习JMM,不断实践,并关注Java并发领域的最新发展。

随着技术的不断进步,JMM和并发编程的实践也在不断演进。持续学习,不断适应新的编程模式和工具,将使您能够在构建高性能、高可靠性的Java应用时保持领先。

Java多线程实战:从JMM、线程安全到Spring Boot工程化 Java多线程是构建高并发后端服务的核心能力,其本质源于JVM内存模型(JMM)对共享可变状态的可见性、有序性与原子性约束。理解volatile的局限性、synchronized与ReentrantLock的适用边界、CAS的无锁代价,是规避竞态条件和死锁的前提;而线程池参数设计、CompletableFuture编排、ThreadLocal内存泄漏防控等,则直接决定Spring Boot微服务在线上环境的稳定性与可观测性。本文聚焦真实生产场景——包括订单履约、支付幂等、实时推荐等典型用例,结合JMH压测数 阅读详情

相关推荐

如何编译RustDesk(Unbuntu 和Android版本)

备注:官方文档上,一边都是基于sciter,这个在后面已经不建议使用了,但是依然可以编译刚开始的时候看官方的文档,涉及的东西比较多,也搞的一头雾水,通过B站上一个视频,可以通过CI/CD来编译,以及act本地试试(最终放弃,大概需要下载大几十G的容器下来)。最终总算明确了方向,可以用自动化流水线来编译。直接看CI/CD的脚本文件文件在.github/workflows目录下,重点研究 bridge.yml 和flutter-build.yml 这两个文件。

lvronglee的专栏 2549

JMM是怎么解决原子性、可见性、有序性问题的?

Java内存模型封装了底层的实现后提供给开发人员一系列和并发处理相关的关键字,,比如volatile、Synchronized、final等,在开发多线程代码的时候,我们可以直接使用 这些关键词来控制并发,从而不需要关心底层的编译器优化、缓存一致性的问题了,所以JMM除了定义了一套规范外,还给开发人员提供了一套在底层封装后的开放的指令。 一.原子性 在java中提供了两个高级的字节码指令moni...

lx_Frolf的博客 2889

【Collibra 驱动 IPD 数据血缘治理】:三层图谱分层展示体系与全链路追踪的技术业务实践

(应用级/数据级/字段级)是理解复杂数据流动的核心手段。其价值不仅体现在可视化的直观性,更在于通过。技术保障血缘不可篡改性,进一步提升IPD数据治理的可靠性。,解决了跨层级血缘分析的性能与可用性矛盾。数据血缘图谱要素定义(字节跳动/腾讯云/信安标委)实现对IPD数据的精准追踪,而数据血缘图谱的。分层交互设计标准(智慧城市数据中台规范)Collibra技术文档(2024)字段级血缘的挑战与解决路径。自动优化血缘路径,并深化。字段级血缘技术实现方案。Collibra通过。图数据库性能优化原理。

百态·数智思维 | 聚焦大数据、量化与未来AI 1244

深入解析JMM:Java内存模型与并发编程

主内存(Main Memory)定义:在JMM中,主内存是所有线程共享的内存区域存储内容:存储所有的共享变量(实例字段、静态字段等),约等于JVM堆中真正被多线程共享的部分 + 方法区的静态变量,或者是计算机中的内存(注意内存和外存的区别)特点:1.线程对共享变量的所有操作(读/写)都必须在主内存中进行2.是线程间通信的媒介3.对应于物理内存,但不等同于JVM堆内存工作内存(Working Memory)定义:每个线程私有的内存区域存储内容:存储该线程使用到的变量的主内存副本,约等于。

FQY__的博客 940

别再手动转格式了!用Java+LibreOffice命令行实现Word批量转PDF(附Docker部署避坑指南)

本文详细介绍了如何利用Java和LibreOffice命令行实现企业级Word批量转PDF的自动化解决方案,包括多线程优化、Docker化部署及常见问题排查。通过代码示例和实战经验,帮助开发者高效处理文档转换需求,提升工作效率并避免常见陷阱。

552

MATLAB/simulink电力系统之变压器仿真+变压器饱和仿真+空载变压器电流畸变原因及仿真+空载合闸励磁涌流仿真+simulink免费仿真资源

单相变压器空载运行时,原边电流主要用来产生主磁场,而电路损耗和铁芯损耗很小,因此即使外加电压很大,空载电流仍然很小。如果想观察某个相对磁导率下电感系数的数值,可以在程序中增加这样的语句,比如,在程序中end语句之后,加上L(100),运行程序后就可以得到相对磁导率为 100时的电感系数值。在交流铁芯线圈中,当交变磁通按照正弦规律变化时,受到磁路饱和的影响,线圈中的电流会发生畸变,并成为尖顶波,这就是所谓的交流磁路电流畸变。需要指出,铁芯内的主磁通Ф可以通过空载时的副边电压从来测量,两者之间的数学关系,即。

m0_37724753的博客 4234

Java内存模型(JMM)

Java 内存模型(Java Memory Model),简称JMM。它定义了 Java 程序中的变量、线程如何和主存以及工作内存进行交互的规则。首先需要明白java的运行时数据区,如下图:​方法区:存储了运行时常量池、字段和方法参数、构造方法等字节码数据。堆:几乎所有的对象实例及数组都存在这里。栈:每一个线程有一个私有的栈,用于存储局部变量、栈帧、动态链接、方法出口等。本地方法栈:与栈类似,不过进入本地方法栈的数据需要通过native关键字表明。

xct5201314的博客 1757

【AI智能体】全场景AI智能体工作台WorkBuddy实战操作详解

全场景AI智能体工作台WorkBuddy实战操作详解

congge 5569

Java内存模型(JMM)完全指南:从硬件架构到并发编程的桥梁

在多核时代,CPU的性能提升主要依赖于缓存和指令重排序等优化技术。不同的硬件平台和操作系统在内存访问模型上存在巨大差异。Java的使命是**“Write Once, Run Anywhere”**——如果Java直接暴露底层硬件的内存访问细节,程序在不同平台上的行为将大相径庭。**Java内存模型(Java Memory Model,简称JMM)**就是为了解决这个问题而诞生的。📌一句话理解:JMM是Java虚拟机定义的一套规范,它屏蔽了不同硬件和操作系统的内存访问差异,定义了多线程程序中。

✨ 欢迎来到【Seal ^_^ 的优快云博客】!✨ 176

AutoSAR从0开始实战 --- 目录

​​​​​​本专栏是全网最真实的AutoSAR实战专栏,博主将从一个0基础小白的身份来讲解AutoSAR工具的配置,以及相应代码的讲解。

wj博客 1730

智能体开发套件(ADK)介绍

city } ---") city_normalized = city . lower() . replace(" " , "") # 模拟天气数据库 mock_weather_db = {

lpfasd123的博客 1414

Java多线程实战:从JMM、锁优化到高并发秒杀落地

Java多线程是并发编程的核心基础,其本质是理解CPU指令重排、JVM内存模型(JMM)与操作系统线程调度的协同机制。volatile关键字通过内存屏障保障可见性与有序性,但无法保证复合操作原子性;synchronized和ReentrantLock的锁升级、AQS队列、公平性策略直接影响高并发场景吞吐与延迟。在电商秒杀、支付幂等、分布式锁等真实业务中,需结合ConcurrentHashMap扩容机制、CAS优化、Redis Lua原子性及租约续期等技术权衡一致性与性能。本文聚焦生产级多线程问题诊断与调优,

weixin_33923762的博客 364

SAN存储与协议,了解SCSI、FC和ISCSI

在前面我们介绍SAN存储及iSCSI协议的时候了解到SAN存储其实是一个CS架构的系统。存储系统本身就是整个系统的服务端。以IP-SAN(也就是基于iSCSI的SAN存储)为例,其整体架构如图1所示。 图1 CS架构 对于存储系统来说,通常是由专业的存储厂商提供,比较知名的如EMC、NetAPP、IBM和日立等等。国内存储厂商也迅速崛起,比较知名的如华为、宏杉、浪潮和同友等等。另外,还有一些小的存储厂商,他们往往集中在某个领域,比如专注文件系统或者块存储等等。 除了专业的存储设备外,其实Linux

shuningzhang的专栏 2686

java之彻底搞懂并发编程、juc

`## 并发编程 1. 什么是juc java.util.concurrent在并发编程中使用的工具类 2. 线程基础 2.1 进程和线程 进程 一个程序,QQ.exe 一个进程往往可以包含多个线程 java有多个线程? 2个 main GC 线程 比如安全管家是一个进程,那么杀毒、垃圾清理都是一个线程 2.2 并发和并行 Erlang 之父 Joe Armstrong 用一张5岁小孩都能看懂的图解释了并发与并行的区别 并发是两个队列交替使用一台咖啡机 并行是两个队列同时使用两台咖

liyu1012的博客 482

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Java高并发编程实战:从原理到性能优化

并发编程是现代分布式系统的核心技术之一,其核心在于解决多线程环境下的资源共享与协调问题。Java内存模型(JMM)通过happens-before原则保证可见性,而volatile和synchronized等关键字则提供了基础同步手段。在工程实践中,合理使用并发工具类如ConcurrentHashMap和ThreadPoolExecutor能显著提升系统吞吐量。随着业务规模扩大,分布式环境下需要采用Redis或Zookeeper实现分布式锁,并结合令牌桶等限流算法保护系统。典型应用场景如秒杀系统,通过库存分

weixin_33483304的博客 90

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

ASP.NET页面优化,性能提升8倍的方法

System.out.printf("温度: %d, 湿度: %d%n", temperature, humidity);// 填充到64字节。if (messageReady) { // volatile读:检查新消息。// 2. 发出信号(volatile写)if (ready) { // 3. 检查信号(volatile读)// volatile写:广播发送。// load X;// 1. 修改本地内存中的副本。

OrV7w9T0R的博客 779

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

《从语法到性能Java并发编程中线程池优化的五大核心策略》

书中通过对比可重入锁(ReentrantLock)、偏向锁及偏向锁膨胀等不同锁策略的实现原理,提出“锁粒度分层”法则:在高并发场景下,通过分段锁(Segment Bucket)对数据结构进行拆分,可在降低锁竞争频率的同时,达到接近无锁的性能表现。本书通过剖析CopyOnWrite的“以读换写”模式和ConcurrentHashMap的彩虹表冲突解决策略,揭示了高效并行数据结构的三个设计法则:1)避免写操作的跨线程传播 2)采用延迟清理机制降低GC压力 3)利用数值型数组替代对象链表结构。

ulDfzltF的博客 308

《Java 100 天进阶之路》第53篇:volatile与JMM(2026版)

摘要:多线程专题第三弹!从 CPU 缓存模型到 JMM 抽象结构,从可见性问题的硬件根源到 volatile 的内存语义(写即刷主存、读即强制重载),从内存屏障的四种类型(StoreStore、StoreLoad、LoadLoad、LoadStore)到 Happens-Before 的 volatile 规则,从 DCL 单例必须加 volatile 的底层原因到 volatile vs synchronized 完整对比。彻底搞懂 JMM 和 volatile,成为排查并发诡异问题的“火眼金睛”。

折哥|智能物流与Java实战,副高数据库工程师。深耕出版社物流WMS/OMS(线体/立库/VGA),也分享Java进阶与OMS电商对接。Oracle→PG实战派。相信沉淀可迁移能力,分享通用技术,不藏不虚。 534

Java内存模型(JMM)

Java内存模型 ​ 在并发程序中,涉及到操作系统的底层,因此我们很难去判断程序的执行是怎样的。同时涉及到多个线程对共享资源的访问。一致性和安全性将会受到严重挑战。所以,我们需要保证多个线程正确的协同工作。Java内存模型可以帮助我们解决这些问题。 # Java内存区域(结构)和Java内存模型 1. java内存区域和Java内存模型是两个不一样的东西。内存区域是指JVM运行时将数据分区域存储,强调与内存空间的划分。 2. Java内存模型时定义了线程和主内存之间的抽象关系,用来屏蔽各种硬件和操作系统的

weixin_43203735的博客 146

Java 中的 `final` 关键字:用途与性能影响

场景:配置参数。实现优势:编译期优化,代码清晰。Java 的final关键字用于变量、方法、类,支持不可变性、安全性和性能优化。用途包括常量定义、防止继承/重写、线程安全等。性能影响主要来自编译期常量折叠和 JIT 内联,热点代码提升 5-10%。电商订单系统通过final实现 P99 延迟 8ms、QPS 12 万。不可变对象final类和字段。常量。方法final内联。监控final是 Java 高质量代码的核心,未来将在不可变性和性能优化中进一步演进。字数:约 5100 字(含代码)

lssffy的博客 1518

性能优化专栏-tomcat性能优化整理

面试题系列-性能优化面试专栏 tomcat性能优化整理 你怎样给tomcat调优、如何加大comcat连接数、怎样加大tomcat的内存、tomcat中如何禁止列目录下的文件、Tomcat有几种部署方式、Tomcat的优化经验

涛子丶白了你一眼的博客 5431

《Java并发编程深度探索从原理到实战的高性能系统设计指南》

本文构建的分析框架表明,优秀的并发系统设计必须是分层优化的渐进过程:从原子操作控制到分布式协议协调,从硬件特性适配到全链路监测,每个层次都需要突破传统的思维框架才能实现质的飞跃。在实现高并发缓存系统时,通过BloomFilter的分片存储策略,结合JEP 343的Structured Concurrency特性,使跨内存层级的数据访问延迟降低40%,这对实时风控系统的响应时间优化具有突破性意义。在分布式计算和云计算主导的今天,多核处理器已成标配,Java并发编程能力成为构建高性能分布式系统的核心技术。

hjPfhqJm的博客 468

java并发_Java并发之内存模型

阅读本文约需要6分钟大家好,我是你们的导师,经常看我朋友圈的同学应该知道,我每天会在微信上给大家免费提供以下服务!1、长期为你提供最优质的学习资源!2、给你解决技术问题!3、每天在朋友圈里分享优质的技术文章!4、每周1、3、5送纸质书籍免费送给大家,每年至少送书800本书!5、为大家推荐靠谱的就业单位!请注意!我上面说的5点全部都是免费的!全网你应该找不到第二家吧!当然,大家在我...

weixin_39608559的博客 63

《Java并发编程深度解析解锁高并发场景下高效线程管理的隐藏技巧》

本研究通过182次真实环境测试和3.6TB性能数据实证:合理应用上述隐性技巧,可将大型Java系统的核心指标(如TCP协议栈线程上下文切换率、G1 GC的CAS失败率、JIT编译器的代码 motions)分别优化63%、78%和92%,同时使单位业务吞吐量的能耗比下降41%。在多核计算时代,Java并发编程已从“可选技术”演变为高性能系统的核心能力。:通过动态监控锁持有时间分布曲线,当热点函数执行时长超过阈值(如15ms)时,自动拆分本地变量隔离域,实验数据显示该策略可提升23.6%的吞吐量。

ZkSEfizn的博客 410

如何快速掌握Java虚拟机规范:10个关键概念解析与学习路径

想要真正深入理解Java编程语言的核心机制吗?Java虚拟机规范是每位Java开发者进阶的必备知识宝典!本文将为你揭示快速掌握Java虚拟机规范的完整指南,通过10个关键概念解析与系统学习路径,让你轻松掌握JVM的核心工作原理。🚀 ## 什么是Java虚拟机规范?📚 Java虚拟机规范(Java Virtual Machine Specification)是Oracle官方发布的权威技术文

gitblog_00105的博客 440

Java高级开发进阶:JVM调优与并发编程实战

Java虚拟机(JVM)作为Java生态的核心运行时环境,其内存管理与性能调优能力直接影响应用稳定性。理解类加载机制、GC算法等底层原理,配合-XX参数调优可解决Young GC频繁等典型生产问题。并发编程方面,Java内存模型(JMM)定义了多线程可见性与有序性规则,正确使用volatile、Atomic类等工具能避免计数丢失等常见陷阱。本系列基于电商等真实场景,演示如何通过Arthas诊断工具快速定位SQL索引缺失等问题,并分享Redisson分布式锁等架构级解决方案,帮助开发者从语法层面向系统级设计进

weixin_33146151的博客 147
上一篇: 我把Java并发代码简化10倍,今年升职加薪稳了!什么是结构化并发?
下一篇: 数据库与缓存一致性:MySQL与Redis的实践指南!
加班不秃顶
博客等级 码龄7年 1822粉丝 599原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值