java原理与源码

www.xservx.com

⚡ JVM内存模型与运行时数据区

Java虚拟机(JVM)是Java程序运行的基石,其核心价值在于实现了“一次编译,到处运行”的跨平台特性。JVM通过抽象出统一的指令集、寄存器组、栈、垃圾回收堆等运行时环境,屏蔽了底层操作系统与硬件差异。深入理解JVM内存模型,是掌握Java性能调优、故障诊断与底层原理的关键前提。

根据《Java虚拟机规范》(Java SE 17版),JVM运行时数据区划分为以下七个逻辑区域:

①程序计数器(Program Counter Register)

每条线程私有的内存空间,用于记录当前线程执行的字节码指令地址。当线程执行Java方法时,该计数器指向方法区中字节码指令的偏移量;若执行Native方法,则值为Undefined。此区域是唯一无OutofMemoryError风险的区域,因其大小固定且仅存储指令指针。

②虚拟机栈(Java Virtual Machine Stacks)

线程私有内存,生命周期与线程同步创建与销毁。每个方法调用会创建一个栈帧(Stack Frame),用于存储局部变量表、操作数栈、动态链接、方法出口等信息。局部变量表存储编译期可知的各种基本数据类型(boolean、byte、char、short、int、float、long、double)、对象引用(reference类型,非对象本身)和returnAddress类型(指向字节码指令的地址)。值得注意的是,long与double类型数据占用两个局部变量空间(slot),其余基本类型各占一个。

③本地方法栈(Native Method Stacks)

为Native方法服务的线程私有内存区域,HotSpot虚拟机将其与虚拟机栈合二为一。当Java调用C/C++编写的Native方法(如System.arraycopy、FileInputStream.read)时,通过JNI(Java Native Interface)在该栈中执行本地方法调用。

④堆(Heap)

线程共享的内存区域,用于存储对象实例与数组。所有通过new创建的对象实例(不含局部变量、方法参数等栈上分配的对象)均分配于堆中。堆是垃圾回收器(GC)管理的核心区域,其结构设计直接影响GC效率与程序性能。JDK 8起默认采用G1垃圾回收器,其将堆划分为多个大小相等的Region(默认1MB~32MB,取决于-Xmx),支持并发标记与增量回收,显著降低Stop-The-World时间。

⑤方法区(Method Area)

线程共享的内存区域,用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码缓存等数据。JDK 8起,HotSpot将方法区实现从永久代(Permanent Generation)迁移到元空间(Metaspace),元空间使用本地内存(Native Memory)而非JVM堆内存,有效避免了永久代OOM问题。元空间的默认初始大小由-XX:MetaspaceSize参数控制,最大大小由-XX:MaxMetaspaceSize指定。

⑥运行时常量池(Runtime Constant Pool)

方法区的一部分,用于存储编译期生成的字面量(literal)与符号引用(symbolic reference)。字面量包括字符串常量、final修饰的基本类型常量;符号引用包括类和接口的全限定名、字段的名称与描述符、方法的名称与描述符等。运行时常量池具备动态性,运行期间可通过String.intern()方法将新字符串加入常量池。

⑦直接内存(Direct Memory)

非JVM运行时数据区的组成部分,但常被NIO使用。通过Unsafe.allocateMemory()或DirectByteBuffer分配的内存位于堆外,受操作系统管理。该内存区域不受堆大小限制,但需手动释放(通过Cleaner机制或PhantomReference),否则易引发内存泄漏。DirectByteBuffer的allocate()方法实际调用的是Unsafe的native方法,其底层通过mmap系统调用映射本地内存。

JVM执行引擎与字节码指令

JVM执行引擎的核心任务是将字节码指令翻译为机器码并执行。其执行模式主要包括解释执行、JIT即时编译与混合模式(默认)。HotSpot虚拟机采用“热点代码检测”策略:当方法调用次数超过阈值(默认10000次,由-XX:CompileThreshold控制)或编译后执行时间超过阈值时,触发JIT编译,将字节码编译为本地机器码并缓存至Code Cache。

Java字节码指令集共206条,分为七大类:

指令类型示例指令功能说明
加载与存储iload, istore, ldc, bipush将变量从局部变量表加载至操作数栈,或反之
算术与逻辑iadd, isub, imul, idiv, irem执行整数加减乘除、取模运算
类型转换i2l, f2d, d2i在基本类型间进行显式转换
对象操作new, getfield, putfield, invokevirtual创建对象、访问字段、调用实例方法
控制转移ifeq, ifne, if_icmpeq, goto实现条件分支与循环跳转
方法调用与返回invokevirtual, invokespecial, return调用方法并处理返回值
异常处理athrow, monitorenter, monitorexit抛出异常、同步块加锁与解锁

以int a = 10; int b = 20; int c = a + b;为例,其字节码指令序列如下:

0: bipush 10
2: istore_1
3: bipush 20
5: istore_2
6: iload_1
7: iload_2
8: iadd
9: istore_3
10: return

该过程体现JVM基于栈的执行模型:先将常量10、20压入操作数栈(bipush),再存储至局部变量表(istore);计算时从局部变量表加载至操作数栈(iload),执行iadd后结果存回局部变量表(istore_3)。

⚙️ 类加载机制与双亲委派模型

类加载子系统负责将Class文件从磁盘读取、验证、准备、解析并最终初始化为JVM中的java.lang.Class对象。整个过程严格遵循《Java虚拟机规范》定义的生命周期:加载 → 验证 → 准备 → 解析 → 初始化 → 使用 → 卸载。其中,验证、准备、解析三阶段统称为连接(Linking)。

类加载器体系结构

JVM内置三类类加载器,形成树状层级结构:

  • 启动类加载器(Bootstrap ClassLoader):由C++实现,负责加载%JAVA_HOME%/lib目录下或-Xbootclasspath指定路径中的核心类库(如rt.jar),是所有类加载器的祖先。
  • 扩展类加载器(Extension ClassLoader):由sun.misc.Launcher$ExtClassLoader实现,负责加载%JAVA_HOME%/lib/ext目录或java.ext.dirs系统属性指定路径中的扩展类库。
  • 应用程序类加载器(Application ClassLoader):由sun.misc.Launcher$AppClassLoader实现,负责加载用户类路径(ClassPath)下的类,是默认的系统类加载器。
〔双亲委派模型工作流程

当类加载器收到类加载请求时,首先委托父加载器尝试加载(向上委派),仅当父加载器无法完成时,子加载器才尝试自行加载(向下尝试)。该模型保障了Java核心库的唯一性与安全性:

  1. 应用程序类加载器收到加载请求后,先委托扩展类加载器;
  2. 扩展类加载器再委托启动类加载器;
  3. 若启动类加载器无法加载(如非rt.jar中的类),则返回至扩展类加载器;
  4. 扩展类加载器尝试加载,失败则返回至应用程序类加载器;
  5. 最终由应用程序类加载器从ClassPath中加载。

该机制有效防止核心API被恶意替换。例如,若自定义java.lang.String类,因启动类加载器已加载rt.jar中的String类,自定义类无法被加载,避免了安全风险。

类加载过程详解

〔加载阶段

通过类的全限定名获取定义此类的二进制字节流;将字节流所代表的静态存储结构转化为方法区的运行时数据结构;在堆中生成java.lang.Class对象,作为访问方法区数据的入口。注意:加载阶段与连接阶段交叉进行,加载可能在连接阶段开始前尚未完成,以支持动态代理与热部署。

〔验证阶段

确保Class文件的字节流符合JVM规范,避免恶意代码危害虚拟机。验证包括:文件格式验证(检查魔数、主次版本号等);元数据验证(检查类是否有父类、是否继承final类等);字节码验证(检查类型安全,如跳转指令是否合理);符号引用验证(确保解析阶段能正确映射到方法区)。

〔准备阶段

为类变量(static修饰的字段)分配内存并设置初始值(零值)。注意:类变量初始值为零值,而非代码中赋值的初始值(如int a=123,准备阶段a=0,初始化阶段才设为123)。若类变量为final static常量(如public static final int VALUE=42),则直接赋初值(VALUE=42)。

〔解析阶段

将常量池中的符号引用转换为直接引用。符号引用以常量池的CONSTANT_Class_info、CONSTANT_Fieldref_info等结构存储;直接引用是直接指向目标的指针、相对偏移量或句柄。解析包括:类或接口解析;字段解析;类方法解析;接口方法解析。解析阶段可能触发类的初始化(如解析字段时发现所属类未初始化)。

〔初始化阶段

执行类构造器()方法的过程,该方法由编译器自动收集类中所有static变量的赋值动作与static代码块生成。执行顺序遵循“先父后子”原则(父类()先于子类执行)。触发初始化的五种场景:遇到new、getstatic、putstatic、invokestatic字节码指令;使用反射调用类;初始化子类时父类未初始化;虚拟机启动时指定主类;动态语言支持调用MethodHandle。

自定义类加载器与SPI机制

自定义类加载器需继承java.lang.ClassLoader,重写findClass()方法(而非loadClass()),利用defineClass()将字节数组转为Class对象。典型应用场景包括:加密Class文件(解密后加载)、热部署(卸载旧类并加载新类)、插件化架构(隔离不同插件的类空间)。

SPI(Service Provider Interface)机制通过Thread.currentThread().getContextClassLoader()绕过双亲委派模型,实现“逆向委派”。例如JDBC驱动加载时,DriverManager使用线程上下文类加载器加载驱动实现类,解决了核心库调用用户代码的困境。

〔 集合框架核心原理与源码剖析

Java集合框架是开发中的高频工具,深入理解其底层实现是写出高效代码的前提。框架以Collection、Map两大顶层接口为核心,通过继承与组合构建出庞大的类体系。本节聚焦高频使用类(ArrayList、LinkedList、HashMap、ConcurrentHashMap)的源码实现逻辑。

ArrayList:动态数组实现

ArrayList基于Object[]数组实现,支持随机访问(O(1)时间复杂度),但插入/删除需移动元素(O(n))。其核心属性包括:

  • elementData:存储元素的数组(transient,避免序列化时冗余);
  • size:实际元素个数;
  • DEFAULT_CAPACITY:默认容量(10);
  • EMPTY_ELEMENTDATA:空数组实例(用于无参构造)。

扩容机制:当添加元素导致size >= elementData.length时,触发扩容。新容量 = 旧容量 + 旧容量/2(即1.5倍),通过Arrays.copyOf()创建新数组并复制元素。例如初始容量10,扩容后为15、22、33……。注意:频繁扩容影响性能,建议预估容量后使用ensureCapacity()预分配。

〔源码关键点
public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    elementData = Arrays.copyOf(elementData, newCapacity);
}

移除元素时,调用fastRemove()方法通过System.arraycopy()将后继元素前移。注意:迭代过程中调用remove()会导致ConcurrentModificationException,应使用Iterator.remove()。

HashMap:哈希表与红黑树

HashMap是基于哈希表的Map接口实现,允许null键与null值(但键唯一)。其核心设计包括:

  • 数组+链表+红黑树:JDK 8起,当链表长度≥8且数组长度≥64时,链表转为红黑树;当红黑树节点≤6时退化为链表;
  • 负载因子:默认0.75(DEFAULT_LOAD_FACTOR),在时间与空间成本间取得平衡;
  • 哈希扰动:(h = key.hashCode()) ^ (h >>> 16),高16位与低16位异或,减少哈希冲突;
  • 容量为2的幂:确保(n - 1) & hash可均匀分布索引。
〔put操作流程

① 计算键的哈希值;② 通过(n-1)&hash确定数组索引;③ 若桶为空,直接插入;④ 若键已存在(equals比较),更新值;⑤ 若为链表,遍历插入;⑥ 若链表长度≥8且数组长度≥64,转为红黑树;⑦ 若数组长度<64,触发扩容。

〔线程不安全场景

多线程下扩容可能引发死循环(JDK 7头插法导致链表成环;JDK 8尾插法避免此问题,但仍有数据丢失风险)。线程安全替代方案:ConcurrentHashMap(分段锁/CAS)、Collections.synchronizedMap()(全表锁)。

ConcurrentHashMap:高并发哈希表

JDK 8的ConcurrentHashMap放弃分段锁,采用CAS + synchronized保证线程安全。核心设计:

  • 节点类型:Node(普通节点)、TreeNode(红黑树节点)、TreeBin(树根节点,含锁);
  • 初始化:通过CAS设置baseCount,首次扩容触发initTable();
  • 扩容机制:支持多线程协作扩容,每个线程处理一个或多个桶(bin);
  • 计数器:使用LongAdder替代AtomicLong,减少竞争。
〔putVal源码精简版
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node[] tab = table;;) {
        Node f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node(hash, key, value, null)))
                break;
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) { binCount = 1; ... }
                    else if (f instanceof TreeBin) { ... }
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

注意:size()方法通过sumCount()累加baseCount与Cell数组,避免全表遍历;mappingCount()返回long类型,避免int溢出。

↑ 并发编程与线程模型

Java并发编程是高并发系统的核心技术,涉及线程生命周期、内存可见性、同步机制、线程池设计等。本节从内存模型到工具类,系统解析并发原理。

Java内存模型(JMM)

JMM定义了线程与主内存的交互规则,核心原则为:原子性、可见性、有序性。

〔原子性

通过synchronized、Lock保证复合操作的原子性。基本类型读写(除long/double外)是原子的。long/double在32位JVM中分两次写入,可能造成“字节撕裂”,需volatile或同步块保证原子性。

〔可见性

通过volatile、synchronized、final保证修改对其他线程可见。volatile变量写入后立即刷新到主内存;读取时强制从主内存加载,避免线程本地缓存不一致。

〔有序性

通过volatile、synchronized禁止指令重排序。volatile通过内存屏障(LoadLoad、StoreStore等)实现;synchronized通过“lock前缀”指令实现Happens-Before关系。

Happens-Before规则是判断线程安全的核心依据,包括:程序顺序规则、监视器锁规则、volatile变量规则、线程启动规则、线程加入规则、中断规则、终结规则。

线程池原理与参数调优

Executors工厂类提供四种线程池,但阿里开发手册禁止使用,推荐直接使用ThreadPoolExecutor构造函数明确参数:

参数说明推荐值
corePoolSize核心线程数CPU核数+1(IO密集型可设为CPU核数*2)
maximumPoolSize最大线程数根据任务特性与内存上限设定
keepAliveTime非核心线程存活时间60秒(默认)
workQueue任务队列有界队列(ArrayBlockingQueue)或SynchronousQueue
threadFactory线程工厂自定义命名(如“biz-pool-%d”)
handler拒绝策略CallerRunsPolicy(回退机制)
〔工作流程

① 提交任务;② 若线程数

〔线程复用原理

线程通过while循环不断从workQueue.take()获取任务。任务执行完毕后,线程不销毁,而是继续等待新任务,实现复用。核心代码在Worker.run()中:

void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    while (task != null || (task = getTask()) != null) {
        w.lock();
        try {
            beforeExecute(wt, task);
            try {
                task.run();
                afterExecute(task, null);
            } catch (Throwable x) {
                afterExecute(task, x);
                throw x;
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }
}

原子类与CAS机制

Atomic包提供CAS(Compare-And-Swap)操作,通过Unsafe类实现无锁并发。CAS包含三个操作数:内存值V、预期值A、新值B。仅当V==A时,将V更新为B,否则重试。

〔ABA问题与解决方案

CAS可能因值变化后恢复原值导致误判(ABA问题)。解决方案:使用AtomicStampedReference添加版本戳,或AtomicMarkableReference添加布尔标记。

〔LongAdder高性能原理

LongAdder通过Cell数组分散热点,每个线程绑定一个Cell,减少CAS竞争。累加时优先更新base字段,失败则尝试Cell数组,最后汇总base与Cell求和。适用于高并发计数场景(如统计PV/UV)。

← NIO模型与零拷贝技术

传统BIO(阻塞IO)在高并发场景下需大量线程,上下文切换开销大。NIO(New IO)基于Reactor模式,通过Selector实现单线程管理多通道,显著提升吞吐量。

NIO三大核心组件

〔Buffer(缓冲区)

固定容量的数组,支持读写切换。关键属性:capacity(容量)、limit(当前可操作位置)、position(当前读写位置)、mark(标记位置)。flip()将limit设为position,position归零,用于写入后读取;clear()重置position=0、limit=capacity。

〔Channel(通道)

双向数据通道,支持异步读写。常用实现:FileChannel(文件IO)、SocketChannel(TCP客户端)、ServerSocketChannel(TCP服务端)、DatagramChannel(UDP)。通道必须配合Buffer使用,无法直接读写数据。

〔Selector(选择器)

多路复用器,监听多个通道的事件(OP_ACCEPT、OP_READ、OP_WRITE、OP_CONNECT)。通过select()轮询就绪通道,避免阻塞等待。典型用法:

Selector selector = Selector.open();
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
ssc.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
    selector.select();
    Iterator it = selector.selectedKeys().iterator();
    while (it.hasNext()) {
        SelectionKey key = it.next();
        it.remove();
        if (key.isAcceptable()) { ... }
        if (key.isReadable()) { ... }
    }
}

零拷贝(Zero-Copy)技术

传统IO流程:内核空间→用户空间→内核空间,涉及4次上下文切换与2次DMA拷贝。零拷贝通过减少数据拷贝次数提升性能:

〔Mmap(内存映射)

将文件映射到用户空间,用户直接操作内存,避免内核→用户拷贝。适用于大文件读写,但需注意映射区域大小限制(通常2GB)。

〔Sendfile

数据全程在内核空间完成拷贝,用户空间仅传递文件描述符。Linux 2.1内核支持,避免用户态与内核态切换。Java通过FileChannel.transferTo()实现。

〔零拷贝对比
技术拷贝次数上下文切换适用场景
BIO4次4次小文件、低并发
Mmap2次2次大文件、随机读写
Sendfile2次(DMA→内核→网卡)2次文件传输(如HTTP静态资源)

Netty通过CompositeByteBuf与Zero-Copy优化,支持消息拼接、文件合并传输,进一步减少内存拷贝。

〔 设计模式在Java中的应用

设计模式是解决常见问题的可复用方案,Java框架广泛采用设计模式提升可维护性与扩展性。以下解析高频模式源码实现。

单例模式

〔枚举单例(最优解)
public enum Singleton {
    INSTANCE;
    public void doSomething() { ... }
}

天然防止反射与序列化破坏,推荐使用。

〔静态内部类
public class Singleton {
    private Singleton() {}
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

利用类加载机制保证线程安全与延迟加载。

代理模式

〔JDK动态代理

基于接口代理,通过Proxy.newProxyInstance()生成代理对象。核心类:InvocationHandler。Spring AOP底层实现之一。

public class ProxyHandler implements InvocationHandler {
    private final Object target;
    public ProxyHandler(Object target) { this.target = target; }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = method.invoke(target, args);
        System.out.println("after");
        return result;
    }
}
〔CGLIB动态代理

基于继承代理,生成目标类子类(重写方法)。适用于无接口场景。Spring默认策略:有接口用JDK代理,无接口用CGLIB。

模板方法模式

〔JDBC执行流程
public abstract class AbstractJdbcDao {
    public final ResultSet query(String sql) throws SQLException {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = dataSource.getConnection();
            ps = conn.prepareStatement(sql);
            return ps.executeQuery();
        } catch (SQLException e) {
            throw e;
        } finally {
            close(ps);
            close(conn); // 模板方法定义固定流程
        }
    }
    protected abstract void close(AutoCloseable c);
}

父类定义骨架流程,子类实现细节(如close实现)。

观察者模式

〔Spring事件驱动模型

核心组件:ApplicationEvent(事件)、ApplicationListener(监听器)、ApplicationEventPublisher(发布者)。Spring 4.2起支持@EventListener注解。

@Component
public class OrderListener {
    @EventListener
    public void handleOrderEvent(OrderCreatedEvent event) {
        System.out.println("Order created: " + event.getId());
    }
}

观察者模式实现解耦,事件发布者与监听者互不依赖,通过ApplicationEventMulticaster分发事件。

→ Spring框架核心原理

Spring是Java生态的核心框架,其两大支柱:IoC(控制反转)与AOP(面向切面编程)。本节解析其源码级实现。

IoC容器初始化流程

以AnnotationConfigApplicationContext为例,初始化过程包括:

〔构造器阶段

① 调用父类GenericApplicationContext创建DefaultListableBeanFactory;② 注册注解配置处理器(ConfigurationClassPostProcessor等)。

〔refresh()核心流程

① prepareRefresh()准备上下文;� obtainFreshBeanFactory()创建BeanFactory;③ prepareBeanFactory()配置工厂;④ postProcessBeanFactory()注册BeanPostProcessor;⑤ invokeBeanFactoryPostProcessors()调用BeanFactory后置处理器;⑥ registerBeanPostProcessors()注册BeanPostProcessor;⑦ initMessageSource()初始化消息源;⑧ initApplicationEventMulticaster()初始化事件广播器;⑨ onRefresh()子类扩展;⑩ registerListeners()注册监听器;⑪ finishBeanFactoryInitialization()实例化单例Bean;⑫ finishRefresh()发布ContextRefreshedEvent。

〔Bean实例化关键步骤

① 通过BeanDefinition获取类名;② 调用createBean();③ resolveBeforeInstantiation()执行InstantiationAwareBeanPostProcessor;④ doCreateBean():a.实例化(createBeanInstance);b.属性填充(populateBean);c.初始化(initializeBean);d.注册DisposableBean。

AOP实现原理

Spring AOP通过代理模式实现,核心类:Advisor(通知器)、Advice(通知)、Pointcut(切点)。

〔代理创建流程

① BeanPostProcessor.postProcessAfterInitialization()拦截;② AopProxyFactory.createAopProxy()判断是否使用JDK代理(有接口)或CGLIB代理;③ 调用getProxy()生成代理对象。

〔通知执行链

调用代理对象方法时,通过ReflectiveMethodInvocation.proceed()执行通知链。每个Advice对应一个Interceptor,按顺序执行。例如:

@Aspect
public class LogAspect {
    @Before("execution(* com..*(..))")
    public void before() { ... }
    @AfterReturning(pointcut = "execution(* com..*(..))", returning = "result")
    public void afterReturning(Object result) { ... }
}

通知类型:Before、AfterReturning、AfterThrowing、After、Around(环绕通知可控制执行流程)。

事务管理机制

Spring事务基于AOP实现,核心接口:PlatformTransactionManager(事务管理器)、TransactionDefinition(事务定义)、TransactionStatus(事务状态)。

〔@Transactional注解解析

① TransactionInterceptor拦截方法调用;② 获取TransactionManager;③ 创建TransactionStatus;④ 执行目标方法;⑤ commit/rollback事务。

〔传播行为

REQUIRED(默认)、REQUIRES_NEW(新事务)、NESTED(嵌套事务,需JDBC 3.0保存点支持)等。