java 唯一数字id算法 java对象的唯一id

Java虚拟机（JVM）本身不提供像关系型数据库那样的内置机制来确保相同属性对象的唯一性。为了在Java中实现这一目标，开发者需要设计自定义管理策略，通常涉及工厂模式、会话管理以及对弱引用的运用。本文将详细探讨如何通过这些模式来控制对象的创建、生命周期和唯一性，同时避免潜在的内存泄漏问题，并确保多线程环境下的数据一致性。

在关系型数据库管理系统（RDBMS）中，通过定义主键（如Book表的isbn），数据库能够自动确保不存在两条具有相同主键的记录。当尝试插入重复主键的记录时，数据库会阻止操作并抛出错误。然而，在Java中，new关键字每次都会创建一个全新的对象实例，即使这些对象的内部属性完全相同。

例如，对于一个Book类：

class Book {    private int isbn;    private String title;    public Book(int isbn, String title) {        this.isbn = isbn;        this.title = title;    }    // getters, equals, hashCode}

执行Book b = new Book(123456, "Effective Java");和Book c = new Book(123456, "Effective Java");会创建两个在内存中独立存在的对象b和c，即使它们代表的是同一本书。JVM没有内置机制来阻止这种重复对象的创建。如果应用程序需要确保特定属性组合的对象在JVM中是唯一的，就需要开发者自行实现一套管理机制。

立即学习“Java免费学习笔记（深入）”；

实现对象唯一性主要面临以下挑战：

针对这些挑战，我们可以采用以下策略：

为了阻止直接通过构造器创建重复对象，我们需要将构造器私有化或限制其访问，并引入一个“工厂”来集中管理对象的创建和获取。工厂模式的核心思想是：当客户端请求一个对象时，工厂首先检查是否已存在一个符合条件的唯一对象；如果存在，则返回现有对象；否则，创建一个新对象并返回。

// 假设Book类已存在，且我们希望通过isbn确保唯一性// 为了防止外部直接创建，可以考虑将Book的构造器设为包私有或通过其他方式限制// 或者，如果Book是记录，则需要一个单独的工厂类来封装创建逻辑。

工厂需要一个地方来存储它已经创建的唯一对象。一个常见的做法是使用一个集合（如Map）来缓存这些对象，以其唯一标识（如isbn）作为键。

WeShop唯象是国内首款AI商拍工具，专注电商产品图片的智能生成。

初始尝试（及其问题）：

// 伪代码，存在内存泄漏问题class BookFactory {    private static final Map<Integer, Book> bookCache = new HashMap<>();    public static Book getOrCreateBook(int isbn, String title) {        if (bookCache.containsKey(isbn)) {            return bookCache.get(isbn);        } else {            Book newBook = new Book(isbn, title); // 假设Book构造器可访问            bookCache.put(isbn, newBook);            return newBook;        }    }}

这种方法的问题在于，bookCache会一直持有对Book对象的强引用。即使应用程序的其他部分不再引用某个Book对象，它也无法被垃圾回收器回收，从而导致潜在的内存泄漏，尤其是在对象数量庞大或生命周期较长的情况下。

解决方案：使用WeakReference为了解决内存泄漏问题，我们可以使用WeakReference（弱引用）。WeakReference所引用的对象在JVM内存不足时，即使还有弱引用指向它，也会被垃圾回收器回收。这意味着，如果一个Book对象除了被工厂的缓存（通过WeakReference）引用外，没有其他强引用，那么它就可以被回收。

import java.lang.ref.WeakReference;import java.util.concurrent.ConcurrentHashMap;import java.util.Optional;// 假设Book类定义为 record 或具有合适的构造器record Book(int isbn, String title) {}class BookFactoryWithWeakRef {    // 使用ConcurrentHashMap保证线程安全    // 存储WeakReference，键为isbn    private final ConcurrentHashMap<Integer, WeakReference<Book>> bookCache = new ConcurrentHashMap<>();    public Optional<Book> get(int isbn) {        WeakReference<Book> ref = bookCache.get(isbn);        if (ref != null) {            Book book = ref.get(); // 获取弱引用指向的实际对象            if (book != null) {                return Optional.of(book);            } else {                // 对象已被回收，从缓存中移除弱引用                bookCache.remove(isbn, ref);            }        }        return Optional.empty();    }    public Book getOrCreate(int isbn, String title) {        // 尝试从缓存获取        Optional<Book> existingBook = get(isbn);        if (existingBook.isPresent()) {            return existingBook.get();        }        // 如果不存在或已被回收，则创建新对象并放入缓存        Book newBook = new Book(isbn, title);        // 使用computeIfAbsent确保原子性，避免多线程冲突        WeakReference<Book> newRef = new WeakReference<>(newBook);        WeakReference<Book> oldRef = bookCache.computeIfAbsent(isbn, k -> newRef);        // 检查是否有其他线程同时创建了，或者旧的引用仍然有效        if (oldRef == newRef) { // 如果是当前线程成功放入            return newBook;        } else { // 如果其他线程先放入了，或者旧引用仍然有效            Book existing = oldRef.get();            if (existing != null) {                return existing; // 返回已存在的对象            } else {                // 旧引用已失效，再次尝试放入                // 这是一个简化，实际生产中可能需要更复杂的循环或重试逻辑                // 或者直接依赖computeIfAbsent的原子性，但需要处理好WeakReference的生命周期                return getOrCreate(isbn, title); // 递归调用，确保获取到有效的Book            }        }    }}

注意： 上述getOrCreate方法在处理WeakReference失效时可能略显复杂。更简洁且线程安全的方式是利用ConcurrentHashMap的compute或computeIfAbsent方法，但需要确保回调函数内部的逻辑能够正确处理WeakReference的生命周期。

一个全局的工厂虽然能实现唯一性，但它仍然是一个全局的缓存，可能会导致以下问题：

为了解决这些问题，我们可以引入“会话（Session）”的概念。一个会话负责管理其自身的唯一对象集合。当一个会话结束并被垃圾回收时，它所管理的所有对象（如果没有其他强引用）也都可以被回收。

import java.util.concurrent.ConcurrentHashMap;import java.util.Optional;// Book类定义record Book(int isbn, String title) {}/** * BookSession 类用于在一个特定的会话中管理Book对象的唯一性。 * 当BookSession实例不再被引用时，其内部管理的Book对象（如果没有其他强引用） * 也可以被垃圾回收。 */class BookSession {    // 使用ConcurrentHashMap来存储Book对象，确保线程安全    // 这里直接存储Book对象，而不是WeakReference，因为Session本身就是其管理的Book的强引用持有者    // Session的生命周期决定了其内部Book对象的生命周期    private final ConcurrentHashMap<Integer, Book> books = new ConcurrentHashMap<>();    /**     * 根据ISBN获取已存在的Book对象。     *     * @param isbn 国际标准书号     * @return 包含Book对象的Optional，如果不存在则为Optional.empty()     */    public Optional<Book> get(int isbn) {        return Optional.ofNullable(books.get(isbn));    }    /**     * 根据ISBN和标题获取或创建一个Book对象。     * 如果已存在相同ISBN的Book，则返回现有对象；否则，创建新对象并返回。     *     * @param isbn 国际标准书号     * @param title 书名     * @return 唯一且已存在的Book对象     */    public Book getOrCreate(int isbn, String title) {        // computeIfAbsent 是原子操作，确保在多线程环境下只有一个Book会被创建并放入Map        return books.computeIfAbsent(isbn, (key) -> new Book(key, title));    }    // 可以添加其他方法，例如 findByTitle, removeBook 等}

使用示例：

public class UniqueObjectDemo {    public static void main(String[] args) {        // 创建一个BookSession实例        BookSession session1 = new BookSession();        // 在session1中获取或创建Book对象        Book book1_1 = session1.getOrCreate(123456, "Effective Java");        System.out.println("Book 1_1 (session1): " + book1_1);        // 再次获取相同ISBN的Book，将返回同一个对象        Book book1_2 = session1.getOrCreate(123456, "Effective Java");        System.out.println("Book 1_2 (session1): " + book1_2);        System.out.println("book1_1 == book1_2: " + (book1_1 == book1_2)); // true        // 获取不同ISBN的Book        Book book1_3 = session1.getOrCreate(789012, "Clean Code");        System.out.println("Book 1_3 (session1): " + book1_3);        System.out.println("\n--- New Session ---");        // 创建另一个BookSession实例        BookSession session2 = new BookSession();        // 在session2中获取或创建相同ISBN的Book        Book book2_1 = session2.getOrCreate(123456, "Effective Java");        System.out.println("Book 2_1 (session2): " + book2_1);        // 注意：book1_1 和 book2_1 是不同的对象实例，因为它们属于不同的Session        System.out.println("book1_1 == book2_1: " + (book1_1 == book2_1)); // false        // 验证session2内部的唯一性        Book book2_2 = session2.getOrCreate(123456, "Effective Java");        System.out.println("book2_1 == book2_2: " + (book2_1 == book2_2)); // true        // 当session1不再被引用时，其内部的Book对象（如果无其他强引用）可被回收        session1 = null; // 失去对session1的强引用        System.gc(); // 提示JVM进行垃圾回收（不保证立即执行）    }}

在Java中实现像RDBMS那样的对象唯一性，需要开发者通过设计模式和内存管理策略来主动实现。核心方法包括：

通过合理地结合这些技术，开发者可以在Java应用程序中有效地实现和管理对象的唯一性，同时兼顾性能、内存效率和并发安全。

以上就是Java中如何确保对象唯一性：工厂模式与会话管理实践的详细内容，更多请关注乐哥常识网其它相关文章！