Bài 7: Multiple Granularity Locking trong Hibernate

Giới thiệu về Multiple Granularity Locking

Khái niệm và lợi ích

Multiple Granularity Locking (MGL) là một kỹ thuật quản lý khóa trong cơ sở dữ liệu cho phép khóa dữ liệu ở nhiều mức độ khác nhau như row-level (mức độ hàng), page-level (mức độ trang), và table-level (mức độ bảng). MGL cung cấp sự linh hoạt và hiệu quả trong việc quản lý khóa, giảm thiểu xung đột và tăng cường khả năng song song (concurrency) của các giao dịch.

Lợi ích chính của MGL bao gồm:

1. Tăng cường khả năng song song: Cho phép nhiều transaction cùng thực hiện trên các phần khác nhau của dữ liệu mà không gây ra xung đột.

2. Giảm overhead của việc khóa: Khóa ở mức độ phù hợp giúp giảm thiểu chi phí và thời gian xử lý liên quan đến việc quản lý khóa.

3. Cải thiện hiệu suất: Tối ưu hóa hiệu suất của hệ thống bằng cách sử dụng khóa có mức độ linh hoạt phù hợp với tình huống cụ thể.

Các mức độ khóa khác nhau: row-level, page-level, table-level

1. Row-Level Locking: Khóa từng hàng trong bảng. Đây là mức độ khóa nhỏ nhất, cho phép nhiều transaction cùng thao tác trên các hàng khác nhau của cùng một bảng mà không xung đột.

2. Page-Level Locking: Khóa một trang của dữ liệu. Một trang thường chứa nhiều hàng, vì vậy khóa ở mức độ này sẽ ít tốn kém hơn so với row-level locking nhưng vẫn cho phép một mức độ song song nhất định.

3. Table-Level Locking: Khóa toàn bộ bảng. Đây là mức độ khóa lớn nhất và có tính chất thô nhất, thường được sử dụng khi toàn bộ bảng cần được thao tác hoặc trong các tình huống khi cần đảm bảo tính nhất quán tuyệt đối của bảng.

Cách triển khai Multiple Granularity Locking trong Hibernate

Cấu hình Hibernate để hỗ trợ khóa nhiều mức độ

Hibernate hỗ trợ nhiều loại khóa khác nhau thông qua các LockMode và LockOptions. Dưới đây là một số LockMode chính:

• LockMode.READ: Dùng cho các thao tác đọc không thay đổi dữ liệu.

• LockMode.WRITE: Được sử dụng khi ghi dữ liệu.

• LockMode.OPTIMISTIC và LockMode.OPTIMISTIC_FORCE_INCREMENT: Dùng cho Optimistic Locking.

• LockMode.PESSIMISTIC_READ và LockMode.PESSIMISTIC_WRITE: Dùng cho Pessimistic Locking.

Bạn có thể cấu hình Hibernate để sử dụng các loại khóa này tùy theo yêu cầu của ứng dụng.

Sử dụng các API Hibernate để quản lý khóa

Hibernate cung cấp các API để quản lý khóa, cho phép bạn xác định và kiểm soát các mức độ khóa khác nhau trong quá trình xử lý transaction.

1. Sử dụng LockMode cho row-level locking:

import org.hibernate.LockMode;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.persistence.EntityManager;

@Service
public class ProductService {

    @Autowired
    private EntityManager entityManager;

    public void updateProduct(Long productId, int newQuantity) {
        Session session = entityManager.unwrap(Session.class);
        Transaction transaction = session.beginTransaction();

        Product product = session.get(Product.class, productId, LockMode.PESSIMISTIC_WRITE);
        product.setQuantity(newQuantity);

        session.save(product);
        transaction.commit();
    }
}

2. Sử dụng LockOptions cho page-level và table-level locking:

import org.hibernate.LockOptions;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.persistence.EntityManager;

@Service
public class OrderService {

    @Autowired
    private EntityManager entityManager;

    public void updateOrder(Long orderId, String newStatus) {
        Session session = entityManager.unwrap(Session.class);
        Transaction transaction = session.beginTransaction();

        LockOptions lockOptions = new LockOptions(LockMode.PESSIMISTIC_WRITE);
        Order order = session.get(Order.class, orderId, lockOptions);
        order.setStatus(newStatus);

        session.save(order);
        transaction.commit();
    }
}

Ví dụ thực tế

Quản lý quyền truy cập dữ liệu trong hệ thống e-commerce

Giả sử bạn có một hệ thống e-commerce cần quản lý quyền truy cập vào dữ liệu của sản phẩm và đơn hàng. Bạn có thể sử dụng Multiple Granularity Locking để đảm bảo rằng các transaction được thực hiện một cách hiệu quả và tránh xung đột.

1. Tạo entity Product và Order:

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Version;

@Entity
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private Integer quantity;

    @Version
    private Integer version;

    // Getters và Setters
}

@Entity
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String status;

    @Version
    private Integer version;

    // Getters và Setters
}

2. Tạo repository cho Product và Order:

import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}

public interface OrderRepository extends JpaRepository<Order, Long> {
}

3. Tạo service để quản lý transaction và áp dụng MGL:

import org.hibernate.LockMode;
import org.hibernate.LockOptions;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.persistence.EntityManager;

@Service
public class EcommerceService {

    @Autowired
    private EntityManager entityManager;

    public void processOrder(Long orderId, Long productId, int quantity) {
        Session session = entityManager.unwrap(Session.class);
        Transaction transaction = session.beginTransaction();

        // Khóa sản phẩm để cập nhật số lượng
        LockOptions productLockOptions = new LockOptions(LockMode.PESSIMISTIC_WRITE);
        Product product = session.get(Product.class, productId, productLockOptions);
        if (product.getQuantity() < quantity) {
            throw new RuntimeException("Not enough stock");
        }
        product.setQuantity(product.getQuantity() - quantity);

        // Khóa đơn hàng để cập nhật trạng thái
        LockOptions orderLockOptions = new LockOptions(LockMode.PESSIMISTIC_WRITE);
        Order order = session.get(Order.class, orderId, orderLockOptions);
        order.setStatus("PROCESSING");

        session.save(product);
        session.save(order);

        transaction.commit();
    }
}

4. Sử dụng service trong controller:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EcommerceController {

    @Autowired
    private EcommerceService ecommerceService;

    @PostMapping("/process-order")
    public String processOrder(@RequestParam Long orderId, @RequestParam Long productId, @RequestParam int quantity) {
        ecommerceService.processOrder(orderId, productId, quantity);
        return "Order processed successfully";
    }
}

Câu hỏi củng cố kiến thức

1. Multiple Granularity Locking (MGL) là gì và lợi ích của nó trong quản lý cơ sở dữ liệu là gì?

   • MGL là kỹ thuật quản lý khóa cho phép khóa dữ liệu ở nhiều mức độ khác nhau như row-level, page-level, và table-level. Lợi ích của MGL bao gồm tăng cường khả năng song song, giảm overhead của việc khóa, và cải thiện hiệu suất hệ thống.

2. Các mức độ khóa khác nhau trong MGL là gì và khi nào nên sử dụng từng mức độ?

   • Các mức độ khóa bao gồm row-level, page-level, và table-level. Row-level dùng khi cần độ chính xác cao và nhiều transaction đồng thời, page-level dùng khi cần khóa một nhóm hàng, và table-level dùng khi cần khóa toàn bộ bảng.

3. Làm thế nào để cấu hình và sử dụng Multiple Granularity Locking trong Hibernate?

   • Bạn có thể cấu hình Hibernate sử dụng các LockMode như PESSIMISTIC_READ, PESSIMISTIC_WRITE, và sử dụng LockOptions để quản lý khóa ở các mức độ khác nhau.