Java 并发编程常用锁总结

最新推荐文章于 2024-07-09 16:46:46 发布
最新推荐文章于 2024-07-09 16:46:46 发布
阅读量898 收藏 24
点赞数 19
分类专栏： java并发编程艺术 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Austin_/article/details/139104933
版权

文章目录

2、常用锁

在 Java 编程中，锁（Locks）是用于控制对共享资源（如对象、变量、文件等）的访问，以避免并发线程引发的竞争条件和数据不一致问题。Java 提供了多种锁机制，以下是主要类型的锁及其用途：

Java 提供的多种锁机制适用于不同的并发控制需求和场景。以下是各种锁机制的使用场景和优缺点：

2.1. 内置锁（Synchronized）

使用场景：

  • 简单的同步需求： 适用于简单的并发控制，如同步方法或代码块，控制对共享资源的访问。
  • 小型项目： 适合小型项目或简单的并发需求，不需要复杂的锁控制。

优点：

  • 使用简单，语法直接。
  • 内置在 Java 语言中，无需额外的库。

缺点：

  • 粒度较粗，可能导致性能瓶颈。
  • 无法中断等待的线程。
  • 不支持尝试获取锁和超时获取锁的功能。
2.1.1 内置锁示例

内置锁（synchronized）是 Java 提供的最简单的锁机制，主要用于方法级别和代码块级别的同步。以下是几个示例：

2.1.1.1. 同步方法

使用 synchronized 关键字可以对整个方法进行同步，确保同一时间只有一个线程能够执行该方法

public class SynchronizedMethodExample {
    private int counter = 0;

    // 同步方法
    public synchronized void increment() {
        counter++;
    }

    public synchronized int getCounter() {
        return counter;
    }

    public static void main(String[] args) {
        final SynchronizedMethodExample example = new SynchronizedMethodExample();
        
        // 创建多个线程来调用同步方法
        Thread t1 = new Thread((new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    example.increment();
                }
            }
        }));

        Thread t2 = new Thread((new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    example.increment();
                }
            }
        }));

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

        // 等待线程结束
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出计数器的值
        System.out.println("Final Counter Value: " + example.getCounter());
    }
}
2.1.1.2. 同步代码块

使用 synchronized 关键字可以对特定的代码块进行同步，指定锁对象来控制同步范围。

public class SynchronizedBlockExample {
    private final Object lock = new Object();
    private int counter = 0;

    // 同步代码块
    public void increment() {
        synchronized (lock) {
            counter++;
        }
    }

    public int getCounter() {
        synchronized (lock) {
            return counter;
        }
    }

    public static void main(String[] args) {
        final SynchronizedBlockExample example = new SynchronizedBlockExample();
        
        // 创建多个线程来调用同步代码块
        Thread t1 = new Thread((new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    example.increment();
                }
            }
        }));

        Thread t2 = new Thread((new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    example.increment();
                }
            }
        }));

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

        // 等待线程结束
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出计数器的值
        System.out.println("Final Counter Value: " + example.getCounter());
    }
}
2.1.1.3 解释
  1. 同步方法：
    • 使用 synchronized 关键字直接在方法声明中，整个方法体是同步的。
    • 当一个线程调用 increment 方法时，其他线程必须等待该方法执行完毕后才能调用该方法或其他同步方法。
  2. 同步代码块：
    • 使用 synchronized 关键字和一个锁对象（如 lock）。
    • 仅在同步代码块内的代码会受到锁的保护，而其他代码不受影响。
    • 提供了更细粒度的控制，可以提高性能。

通过这两种方式，可以确保对共享资源（如 counter 变量）的访问是线程安全的，避免并发修改带来的数据不一致问题。

2.2. 显式锁（Explicit Locks）

使用场景：

  • 复杂的同步需求： 适用于复杂的并发控制，如需要实现公平锁、公平队列或中断锁等。
  • 大规模项目： 适合需要高度自定义和灵活控制并发的场景。

优点：

  • 支持可中断锁获取、尝试获取锁和超时获取锁。
  • 提供了更多控制，如公平性设置。
  • 可以实现更细粒度的锁定，提高并发性能。

缺点：

  • 使用较复杂，需要显式地获取和释放锁。
  • 容易出现死锁，如果不小心使用会导致问题。

示例：ReentrantLock

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

public class ReentrantLockExample {
    private final Lock lock = new ReentrantLock();

    public void someMethod() {
        lock.lock();
        try {
            // critical section
        } finally {
            lock.unlock();
        }
    }
}
2.3 读写锁（ReadWriteLock）

使用场景：

  • 读多写少的场景： 适用于读操作频繁而写操作较少的场景，如缓存系统、配置读取等。

优点：

  • 读锁可以同时被多个线程持有，提高读操作的并发性。
  • 写锁是独占的，保证写操作的原子性。

缺点：

  • 写操作时，所有读操作会被阻塞。
  • 实现较为复杂。

示例：ReentrantReadWriteLock

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void readMethod() {
        rwLock.readLock().lock();
        try {
            // read critical section
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void writeMethod() {
        rwLock.writeLock().lock();
        try {
            // write critical section
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}
2.4. 自旋锁（SpinLock）

自旋锁（SpinLock）是一种忙等待锁机制，线程在等待锁时不会进入阻塞状态，而是不断循环检查锁的状态，直到获得锁。这种机制避免了线程上下文切换的开销，适用于锁持有时间短、线程数量少的高频临界区场景。

使用场景

自旋锁适用于以下场景：

  1. 锁持有时间短：自旋锁适合那些持锁时间非常短的场景，如果锁持有时间长，自旋等待会浪费 CPU 资源。
  2. 低线程竞争：适用于线程数量较少、锁竞争不激烈的场景，高线程竞争下自旋锁可能导致性能下降。
  3. 高性能要求：自旋锁在避免线程阻塞和上下文切换方面表现出色，非常适合性能要求高的场景。

自旋锁示例

以下是一个简单的 Java 自旋锁实现示例：

import java.util.concurrent.atomic.AtomicBoolean;

public class SpinLock {
    private AtomicBoolean lock = new AtomicBoolean(false);

    public void lock() {
        while (!lock.compareAndSet(false, true)) {
            // 自旋等待
        }
    }

    public void unlock() {
        lock.set(false);
    }

    public static void main(String[] args) {
        final SpinLock spinLock = new SpinLock();
        Runnable task = (new Runnable() {
            @Override
            public void run() {
                spinLock.lock();
                try {
                    // 临界区
                    System.out.println(Thread.currentThread().getName() + " acquired the lock");
                } finally {
                    spinLock.unlock();
                    System.out.println(Thread.currentThread().getName() + " released the lock");
                }
            }
        });

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

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

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
2.5. 悲观锁（Pessimistic Locking）和乐观锁（Optimistic Locking）
  • 悲观锁： 采用较重的锁机制，认为每次访问数据时都会发生冲突，因此会对数据进行锁定。
  • 乐观锁： 采用较轻的锁机制，认为冲突不会频繁发生，在操作前不锁定数据，而是在提交时检查冲突。

乐观锁通常通过版本号或时间戳机制实现。

2.5.1. 悲观锁（Pessimistic Locking）

悲观锁（Pessimistic Locking）是一种在并发控制中假设冲突是常态，因此在访问资源时会先进行加锁操作，以防止其他线程或事务对资源进行修改。悲观锁通常用于需要严格数据一致性保障的场景，例如数据库系统中。

使用场景

悲观锁适用于以下场景：

  1. 高冲突场景：数据更新频繁，多个事务或线程可能会同时修改同一数据，使用悲观锁可以确保数据的一致性。
  2. 严格一致性要求：应用程序对数据一致性要求非常高，不能接受任何数据不一致的情况，例如金融系统中的交易操作。
  3. 长时间持有锁：当业务逻辑需要长时间持有锁且过程中需要进行多次操作时，悲观锁可以防止其他事务的干扰。
悲观锁示例

以下是一个在 Java 中使用悲观锁的示例，模拟数据库操作。假设我们有一个银行账户，我们希望在取款和存款操作时确保线程安全性。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class PessimisticLockingExample {
    private static final String DB_URL = "jdbc:mysql://localhost:3306/testdb";
    private static final String USER = "username";
    private static final String PASS = "password";

    public static void main(String[] args) {
        final PessimisticLockingExample example = new PessimisticLockingExample();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                example.withdraw(1, 100);
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                example.withdraw(1, 200);
            }
        });

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

    public void withdraw(int accountId, int amount) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;

        try {
            conn = DriverManager.getConnection(DB_URL, USER, PASS);
            conn.setAutoCommit(false);

            // 悲观锁：锁定账户记录，防止其他事务修改
            String selectSQL = "SELECT balance FROM accounts WHERE id = ? FOR UPDATE";
            pstmt = conn.prepareStatement(selectSQL);
            pstmt.setInt(1, accountId);
            rs = pstmt.executeQuery();

            if (rs.next()) {
                int balance = rs.getInt("balance");
                if (balance >= amount) {
                    String updateSQL = "UPDATE accounts SET balance = balance - ? WHERE id = ?";
                    pstmt = conn.prepareStatement(updateSQL);
                    pstmt.setInt(1, amount);
                    pstmt.setInt(2, accountId);
                    pstmt.executeUpdate();
                    System.out.println("Withdraw successful, new balance: " + (balance - amount));
                } else {
                    System.out.println("Insufficient funds");
                }
            }
            conn.commit();
        } catch (SQLException e) {
            e.printStackTrace();
            try {
                if (conn != null) {
                    conn.rollback();
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            try {
                if (rs != null) rs.close();
                if (pstmt != null) pstmt.close();
                if (conn != null) conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

解释

  1. 数据库连接：
    • 使用 JDBC 连接到 MySQL 数据库，并在操作之前禁用自动提交 (conn.setAutoCommit(false)) 以便手动控制事务。
  2. 悲观锁：
    • SELECT balance FROM accounts WHERE id = ? FOR UPDATE：使用 FOR UPDATE 语句对账户记录进行加锁，防止其他事务在当前事务完成之前对该记录进行修改。
    • FOR UPDATE 确保在读取账户余额后，其他事务无法更新同一账户记录，直到当前事务提交或回滚。
  3. 业务逻辑：
    • 查询账户余额，如果余额充足则执行扣款操作。
    • 如果余额不足，输出提示信息。
  4. 事务控制：
    • 成功执行后提交事务 (conn.commit())，确保变更持久化。
    • 出现异常时回滚事务 (conn.rollback())，保证数据一致性。

总结

通过使用悲观锁，可以确保在高冲突和高一致性要求的场景中，数据操作的安全性和一致性。虽然悲观锁可能导致锁竞争和性能下降，但在需要严格数据保护的应用中，它是一种有效的并发控制机制。

2.5.2. 乐观锁（Optimistic Locking）

使用场景：

  • 无冲突操作： 适用于冲突较少的场景，如版本控制系统、数据库事务等。
  • 高性能需求： 适合需要高并发和高性能的场景。

优点：

  • 不需要加锁，可以提高性能。
  • 冲突检测机制减少了锁竞争，提高了并发性。

缺点：

  • 需要冲突检测和重试机制，增加了实现复杂度。
  • 在冲突频繁的场景下性能较差。

示例：使用 java.util.concurrent.atomic 包中的类

public class OptimisticLockingExample {
    private AtomicInteger value = new AtomicInteger(0);

    public void increment() {
        int oldValue, newValue;
        do {
            oldValue = value.get();
            newValue = oldValue + 1;
        } while (!value.compareAndSet(oldValue, newValue));
    }

    public int getValue() {
        return value.get();
    }

    public static void main(String[] args) {
        OptimisticLockingExample optimisticLocking = new OptimisticLockingExample();
        for (int i = 0; i < 10; i++) {
            optimisticLocking.increment();
        }
        System.out.println(optimisticLocking.getValue());
    }
}
解释
  1. AtomicBoolean：
    • 自旋锁使用 AtomicBoolean 来表示锁状态，初始值为 false 表示锁未被占用。
    • compareAndSet(false, true) 方法尝试将 lock 从 false 设置为 true，如果成功则表示获得了锁。
  2. lock 方法：
    • 使用 while 循环和 compareAndSet 方法实现自旋等待。
    • 当锁状态为 false 时，线程将锁状态设置为 true 并退出循环。
    • 如果锁状态为 true，线程将继续自旋等待。
  3. unlock 方法：
    • 使用 set(false) 方法将锁状态重置为 false，释放锁。
  4. 示例使用：
    • 创建两个线程 t1 和 t2，它们分别尝试获取锁并进入临界区。
    • 获取锁后，线程打印锁定信息，然后在 finally 块中释放锁。
自旋锁的注意事项
  1. 忙等待：
    • 自旋锁会不断检查锁的状态，如果锁持有时间过长，忙等待会浪费大量 CPU 资源。
    • 因此，自旋锁适用于锁持有时间非常短的场景。
  2. 线程数限制：
    • 自旋锁在高线程竞争的场景下表现不佳，因为大量线程会进行忙等待，导致性能下降。
  3. 公平性：
    • 自旋锁通常是非公平的，无法保证等待线程的先后顺序。
适用场景总结

自旋锁非常适合以下场景：

  • 临界区代码执行速度极快，锁持有时间短。
  • 线程数较少，锁竞争不激烈。
  • 高性能要求，需要避免线程上下文切换的开销。

对于其他场景，例如锁持有时间长或线程数量多，推荐使用其他锁机制，如内置锁（synchronized）或显式锁（如 ReentrantLock），以避免自旋锁带来的性能问题。

2.6. StampedLock

StampedLock 是 Java 8 引入的一种高级锁机制，提供了对传统锁（如 ReentrantLock 和 ReadWriteLock）的替代方案。它支持三种模式的锁：写锁、悲观读锁和乐观读锁。StampedLock 设计的目的是在高并发场景下提高性能，特别是读多写少的场景。

2.6.1 使用场景

StampedLock 适用于以下场景：

  1. 读多写少：主要用于读操作非常频繁，而写操作相对较少的场景。在这种场景下，StampedLock 的乐观读锁可以显著提升并发性能。
  2. 需要减少锁竞争：通过乐观读锁减少读操作之间的锁竞争，提高并发性。
  3. 高性能要求：对性能有较高要求，需要尽量减少线程阻塞和上下文切换开销的场景。
2.6.2 示例

下面是一个使用 StampedLock 的示例，模拟一个简单的点（Point）的坐标操作。

示例：使用 StampedLock 保护坐标操作

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private double x, y;
    private final StampedLock lock = new StampedLock();

    // 写锁：更新坐标
    public void move(double deltaX, double deltaY) {
        long stamp = lock.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    // 悲观读锁：读取坐标
    public double[] getCoordinates() {
        long stamp = lock.readLock();
        try {
            return new double[] { x, y };
        } finally {
            lock.unlockRead(stamp);
        }
    }

    // 乐观读锁：尝试读取坐标
    public double distanceFromOrigin() {
        long stamp = lock.tryOptimisticRead();
        double currentX = x, currentY = y;

        // 校验乐观读锁是否有效
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }

    public static void main(String[] args) {
        StampedLockExample point = new StampedLockExample();
        point.move(1.0, 1.0);
        System.out.println("Coordinates: " + java.util.Arrays.toString(point.getCoordinates()));
        System.out.println("Distance from origin: " + point.distanceFromOrigin());

        Thread t1 = new Thread(() -> {
            point.move(2.0, 2.0);
        });

        Thread t2 = new Thread(() -> {
            System.out.println("Distance from origin (from thread): " + point.distanceFromOrigin());
        });

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

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Coordinates: " + java.util.Arrays.toString(point.getCoordinates()));
    }
}
2.6.3 解释
  1. 写锁：
    • long stamp = lock.writeLock(); 获取写锁，stamp 是锁的票据，用于解锁。
    • try 块中更新坐标值 x 和 y。
    • finally 块中调用 lock.unlockWrite(stamp); 释放写锁。
  2. 悲观读锁：
    • long stamp = lock.readLock(); 获取悲观读锁。
    • try 块中读取坐标值并返回。
    • finally 块中调用 lock.unlockRead(stamp); 释放读锁。
  3. 乐观读锁：
    • long stamp = lock.tryOptimisticRead(); 尝试获取乐观读锁。
    • 读取坐标值 x 和 y。
    • if (!lock.validate(stamp)) { ... } 校验乐观读锁是否有效。如果无效，获取悲观读锁重新读取坐标。
2.6.4 总结

StampedLock 提供了三种锁模式，可以在不同场景下使用：

  • 写锁：独占锁，用于写操作，确保数据一致性。
  • 悲观读锁：与传统的读锁类似，多个读线程可以同时获取，但写线程会阻塞。
  • 乐观读锁：轻量级锁，可以在大多数情况下无锁地进行读操作，但在检测到数据修改时会回退到悲观读锁。

通过使用 StampedLock，可以在高并发、读多写少的场景下显著提高性能和吞吐量。

Austinu
关注
  • 19
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程进阶——并发锁
行者无疆的博客
03-14 4161
1 JAVA 多线程锁介绍 1.1 悲观锁 定义：悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改（很悲观），所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态。 悲观锁的实现：开发中常见的悲观锁实现往往依靠数据库提供的锁机制，即在数据库中，在对数据记录操作前给记录加排它锁。如果获取锁失败，则说明数据正在被其他线程修改，当前线程则等待或者抛出异常。如果获取锁成功，则对记录进行操作，然后提交事务后释放排它锁。 实例：Java 中的 synchronized 关键
Java并发编程实战经验总结-并发编程进阶必读
11-21
适合人群： 适合有一定Java基础且想在并发领域有更深入研究的你。同样适合从业2-3年，...1.Java并发基础与演变过程； 2.Java SDK常用并发工具类使用技巧及原理； 3.并发编程设计模式，助力你在工作中更好的运用并发。
Java 并发编程
m0_61470267的博客
06-05 9145
java线程的回顾，java多线程出现的问题及解决方案，引入线程池的的原因，线程池的参数设置，以及引入ThreadLocal 线程变量，理解ThreadLocal的底层实现原理。
java并发总结
liujiqing123的博客
10-11 1万+
一、并发基础 ㅤ 1、进程与线程 ㅤ 进程 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等） 线程 一个进程之内可以分为一到多个
Java并发编程详解：实现高效并发应用的关键技术
热门推荐
唯有努力，方可自信！
06-22 1万+
本文介绍了Java并发编程的关键技术，包括线程安全性、锁机制、并发集合、原子操作和并发工具。通过使用synchronized关键字和ReentrantLock锁来实现线程安全性，使用ConcurrentHashMap和CopyOnWriteArrayList等并发集合来实现安全数据访问，以及使用AtomicBoolean和AtomicInteger等原子类来实现线程安全的原子操作。此外，还介绍了CountDownLatch和CyclicBarrier等并发工具，用于线程间的同步操作。通过学习和运用这些技术，
Java并发编程
qq_51707222的博客
01-25 3936
回顾线程的基本内容 程序：静态代码 安装在硬盘上的。 进程：运行的程序，是操作系统分配内存的空间单位。 线程：是进程中的最小执行单位，是cpu的调度单位，线程依赖于进程。 创建线程 线程类 继承Thread 类 实现Runnable接口 重写run(） 创建Thread类的对象，为其分配任务。 类 实现 Callable接口 重写call()方法 有返回值 可以抛出异常。 创建Thread类的对象，为其分配任务。 常用的方法 run() call() start() 线程状态 start() 就绪态
Java多线程并发编程和锁原理解析
08-25
Java多线程并发编程和锁原理解析是Java并发编程中非常重要的知识点，文章通过示例代码详细介绍了Java多线程并发编程和锁原理解析，对大家的学习或者工作具有一定的参考学习价值。 乐观锁和悲观锁 在Java多线程并发...
Java并发编程面试题目
07-01
" Java并发编程面试题目" Java并发编程是Java编程语言中的一种核心技术，旨在提高程序的执行效率和响应速度。并发编程的优点是可以提高程序的执行效率，提高用户体验和系统性能。但是， 并发编程也存在一些缺点，...
Java 并发编程实战
05-21
3.5.3　安全发布的常用模式 3.5.4　事实不可变对象 3.5.5　可变对象 3.5.6　安全地共享对象 第4章　对象的组合 4.1　设计线程安全的类 4.1.1　收集同步需求 4.1.2　依赖状态的操作 4.1.3　状态的所有权 4.2　实例...
java Object 转 Integer
servepeople的博客
07-09 326
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1350
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 899
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
最新发布
qq_44304677的博客
07-09 255
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
ShardingSphere
Casual_Lei的博客
07-04 724
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 1004
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
基于SpringBoot的招聘信息管理系统的详细设计和实现(源码+lw+部署文档+讲解等，欢迎咨询我！！)
程序员阿龙的博客
07-06 974
本次分享的是一个基于java开发的招聘信息管理系统，也说明了自己的开发实力，欢迎各位小伙伴来咨询相关业务，也可以参考一下这个文章！！
返回值处理器器【Spring源码学习】
weixin_44794897的博客
07-05 301
定义返回值类型处理器的组合；测试使用的controller测试方法。
学习mybatis
weixin_45621552的博客
07-08 578
【代码】学习mybatis。
基于springboot的工作绩效管理系统的设计与实现+文档
欧阳小白闯天涯
07-05 711
本毕业设计旨在设计与实现基于Spring Boot的工作绩效管理系统，以满足现代企业对绩效管理的需求。随着企业规模的不断扩大和竞争日益激烈，高效的绩效管理成为提升企业竞争力的重要手段。本系统将利用Spring Boot框架搭建，结合MySQL数据库和MyBatis持久层框架，以及Thymeleaf模板引擎，为企业提供全面的绩效管理解决方案。系统功能包括员工和管理员两个角色。员工可通过系统进行绩效管理、工资管理、统计分析、请假管理以及公告管理等操作，从而提升工作效率和满足个人需求。
Java 并发编程硬核资料.pdf
09-19
在Java并发编程中，了解并掌握这些内容至关重要： 一、多线程基础 1. 创建线程主要有三种方式：继承Thread类、实现Runnable接口以及使用ExecutorService和Callable接口。 2. Future接口主要用来获取异步计算的结果...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值