為什麽取1248

二進制

CRUD

移位效率高

在並發和效率選擇一個平衡點

一般不會考慮幻讀 因為我們不會再一個事務裏查詢兩次，（只能設置為seralizable）

悲觀鎖和樂觀鎖的前提是read-uncommitted

在數據庫中 默認是repeatable read

悲觀鎖是想著總有人要更改 所以使用數據庫的鎖

樂觀鎖是在程序級別的 設置一個版本號 如果前後不一致就進行自己的操作

例子

悲觀所

Acocount

package com.bjsxt.hibernate;

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

@Entity
 
public class Account {
    private int id;
    private int balance; //BigDecimal
    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getBalance() {
        return balance;
    }
    public void setBalance(int
 
 balance) {
        this.balance = balance;
    }
    
    
}

Test

    @Test
    public void testSave() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        Account a = new Account();
        a.setBalance(100);
        session.save(a);
            
        session.getTransaction().commit();
        session.close();
    }
    
    @Test
    
 
public void testOperation1() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        Account a = (Account)session.load(Account.class, 1);
        int balance = a.getBalance();
        //do some caculations
        balance = balance - 10;
        a.setBalance(balance);
        session.getTransaction().commit();
        session.close();
    }
    
    @Test
    public void testPessimisticLock() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        Account a = (Account)session.load(Account.class, 1, LockMode.UPGRADE);   //設置數據庫鎖 不讓其他事務訪問
        int balance = a.getBalance();
        //do some caculation
        balance = balance - 10;
        a.setBalance(balance);
        session.getTransaction().commit();
        session.close();
    }
    

樂觀鎖

Account

package com.bjsxt.hibernate;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Version;          //註意：Version 不用自己設置

@Entity
public class Account {
    private int id;
    private int balance;
    private int version;
    @Version
    public int getVersion() {
        return version;
    }
    public void setVersion(int version) {
        this.version = version;
    }
    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getBalance() {
        return balance;
    }
    public void setBalance(int balance) {
        this.balance = balance;
    }
    
    
}

    @Test
    public void testSchemaExport() {
        new SchemaExport(new AnnotationConfiguration().configure()).create(
                false, true);
    }

    @Test
    public void testSave() {
        Session session = sf.openSession();
        session.beginTransaction();

        Account a = new Account();
        a.setBalance(100);
        session.save(a);

        session.getTransaction().commit();
        session.close();
    }

    @Test
    public void testOptimisticLock() {
        Session session = sf.openSession();

        Session session2 = sf.openSession();

        
        
        
        session.beginTransaction();
        Account a1 = (Account) session.load(Account.class, 1);
        

        session2.beginTransaction();
        Account a2 = (Account) session2.load(Account.class, 1);   //Version不用自己設置
        
        a1.setBalance(900);
        a2.setBalance(1100);

        session.getTransaction().commit();
        System.out.println(a1.getVersion());

        session2.getTransaction().commit();
        System.out.println(a2.getVersion());

        session.close();
        session2.close();
    }

Hibernate 再接觸 悲觀鎖和樂觀鎖