并发控制、悲观锁、乐观锁

并发控制

当数据库系统采用Read Committed隔离级别时，会导致不可重复读取和两次更新丢失的并发问题，可以在应用程序中采用锁机制来避免这类问题的产生。

从应用程序的角度上看，锁可以分为乐观锁和悲观锁两大类。

悲观锁

在多个客户端可能读取同一笔数据或同时更新一笔数据的情况下，必须要有访问控制的手段，防止同一个数据被修改而造成混乱，最简单的手段就是对数据进行锁定。在自己进行数据读取或更新等动作时，锁定其他客户端不能对同一笔数据进行任何的动作。

悲观锁（Pessimistic Locking），如其名称所示，悲观地认定每次资料存取时，其他的客户端也会存取同一笔数据，因此将会锁住该笔数据，直到自己操作完成后再解除锁。

悲观锁假定任何时刻存取数据时，都可能有另一个客户也正在存取同一笔数据，因而对数据采取了数据库层次的锁定状态，在锁定的时间内其他的客户不能对数据进行存取。对于单机或小系统而言，这并不成问题，然而如果是在网络上的系统，同时间会有许多访问的机器，如果每一次读取数据都造成锁定，其后继的存取就必须等待，这将造成效能上的问题，造成后继使用者的长时间等待。

悲观锁通常透过系统或数据库本身的功能来实现，依赖系统或数据库本身提供的锁机制。Hibernate即是如此，可以利用Query或Criteria的setLockMode()方法来设定要锁定的表或列及其锁模式，可设定的锁模式有以下几个。

LockMode.UPGRADE：利用数据库的for update子句进行锁定。

LockMode.UPGRADE_NOWAIT：使用for update nowait子句进行锁定，在Oracle数据库中使用。

下面来实现一个简单的例子，测试一下采用悲观锁时数据库是如何进行操作的。

首先来完成一个实体对象——User，该对象包含了id，name和age三个属性，实现的方法如清单14.1所示。

清单14.1 User对象的实现

package cn.hxex.hibernate.lock;

public class User {

private String id;

private String name;

private Integer age;

// 省略了getter和setter方法

……

}

接下来就是映射文件的配置，由于该映射文件没有涉及到任何与其他对象的关联配置，所以实现的方法也非常简单，代码如清单14.2所示。

清单14.2 User映射文件的实现

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.hxex.hibernate.lock">

</id>

</class>

</hibernate-mapping>

另外一件重要的工作就是Hibernate的配置文件了，在这个配置文件中包含了连接数据库的参数以及其他一些重要的参数，实现的方法如清单14.3所示。

清单14.3 Hibernate配置文件的实现

<?xml version='1.0' encoding='UTF-8'?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<!-- property name="hibernate.connection.url">

jdbc:oracle:thin:@192.168.10.121:1521:HiFinance</property-->

jdbc:mysql://localhost:3306/lockdb?useUnicode=true&characterEncoding=utf8&autoReconnect=true&autoReconnectForPools=true

</property>

<!-- property name="hibernate.connection.driver_class">

oracle.jdbc.driver.OracleDriver</property-->

com.mysql.jdbc.Driver

</property>

<property name="hibernate.connection.username">lockdb</property>

<property name="hibernate.connection.password">lockdb</property>

<!-- property name="hibernate.dialect">

org.hibernate.dialect.Oracle9Dialect</property -->

org.hibernate.dialect.MySQLDialect</property>

<property name="hibernate.current_session_context_class">thread</property>

<property name="hibernate.hbm2ddl.auto">update</property>

</session-factory>

</hibernate-configuration>

最后要实现的就是测试主程序了，在测试主程序中包含了Hibernate的初始化代码以及悲观锁的测试方法。测试主程序的实现方法如清单14.4所示。

清单14.4 测试主程序的实现

package cn.hxex.hibernate.lock;

import java.net.URL;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.hibernate.LockMode;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

public class LockMain {

private static Log log = LogFactory.getLog( LockMain.class );

// 静态Configuration和SessionFactory对象的实例（全局唯一的）

private static Configuration configuration;

private static SessionFactory sessionFactory;

static

{

// 从默认的配置文件创建SessionFactory

try

{

URL configURL = ClassLoader.getSystemResource(

"cn/hxex/hibernate/lock/hibernate.cfg.xml" );

// 创建默认的Configuration对象的实例

configuration = new Configuration();

// 读取hibernate.properties或者hibernate.cfg.xml文件

configuration.configure( configURL );

// 使用静态变量来保持SessioFactory对象的实例

sessionFactory = configuration.buildSessionFactory();

}

catch (Throwable ex)

{

// 输出异常信息

log.error("Building SessionFactory failed.", ex);

ex.printStackTrace();

throw new ExceptionInInitializerError(ex);

}

public static SessionFactory getSessionFactory() {

return sessionFactory;

}

public void testPessimisticLock() {

SessionFactory sf = LockMain.getSessionFactory();

Session session = sf.getCurrentSession();

session.beginTransaction();

Query query = session.createQuery("from User user");

query.setLockMode("user", LockMode.UPGRADE);

List users = query.list();

for( int i=0; i<users.size(); i++ ) {

System.out.println( users.get( i ) );

}

session.getTransaction().commit();

}

public static void main(String[] args) {

LockMain main = new LockMain();

main.testPessimisticLock();

}

在上面的清单中，testPessimisticLock()方法就是测试悲观锁的方法，该方法在执行查询之前通过Query对象的setLockMode()方法设置了访问User对象的模式，这样，这个程序在执行的时候就会使用以下的SQL语句：

select user0_.userId as userId0_, user0_.name as name0_, user0_.age as age0_

from USERINFO user0_ for update

除了Query对象外，也可以在使用Session的load()或是lock()时指定锁模式。

除了前面所提及的两种锁模式外，还有三种Hibernate内部自动对数据进行加锁的模式，但它的处理是与数据库无关的。

LockMode.WRITE：在insert或update时进行锁定，Hibernate会在调用save()方法时自动获得锁。

LockMode.READ：在读取记录时Hibernate会自动获得锁。

LockMode.NONE：没有锁。

如果数据库不支持所指定的锁模式，Hibernate会选择一个合适的锁替换，而不是抛出一个异常。

乐观锁

乐观锁（Optimistic Locking）认为资料的存取很少发生同时存取的问题，因而不做数据库层次上的锁定。为了维护正确的数据，乐观锁是使用应用程序上的逻辑来实现版本控制的。

在使用乐观锁策略的情况下，数据不一致的情况一旦发生，有几个解决方法，一种是先更新为主，一种是后更新为主，比较复杂的就是检查发生变动的数据来实现，或是检查所有属性来实现乐观锁。

Hibernate中通过检查版本号来判断数据是否已经被其他人所改动，这也是Hibernate所推荐的方式。在数据库中加入一个version字段记录，在读取数据时连同版本号一同读取，并在更新数据时比较版本号与数据库中的版本号，如果等于数据库中的版本号则予以更新，并递增版本号，如果小于数据库中的版本号就抛出异常。

下面就来在前面例子的基础上进行Hibernate乐观锁的测试。

首先需要修改前面所实现的业务对象，在其中增加一个version属性，用来记录该对象所包含数据的版本信息，修改后的User对象如清单14.5所示。

清单14.5 修改后的User对象

package cn.hxex.hibernate.lock;

public class User {

private String id;

private Integer version; // 增加版本属性

private String name;

private Integer age;

// 省略了getter和setter方法

……

}

然后是修改映射文件，增加version属性的配置。在这里需要注意的是，这里的version属性应该使用专门的<version>元素来进行配置，这样才能使其发挥乐观锁的作用。如果还使用<property>元素来进行配置，那么Hibernate只会将其作为一个普通的属性来进行处理。

修改后的映射文件如清单14.6所示。

清单14.6 修改后的映射文件

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.hxex.hibernate.lock">

</id>

</class>

</hibernate-mapping>

接下来还要进行测试主程序的修改。由于需要模拟两个人同时修改同一个记录的情况，所以在这里需要将主程序修改为是可以多线程执行的，然后在run()方法中，调用对User对象的修改程序。

实现后的主测试程序如清单14.7所示。

清单14.7 修改后的测试主程序

package cn.hxex.hibernate.lock;

import java.net.URL;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.hibernate.LockMode;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

public class LockMain extends Thread{

……

public void testOptimisticLock() {

SessionFactory sf = LockMain.getSessionFactory();

Session session = sf.openSession();

Transaction tx = session.beginTransaction();

User userV1 = (User)session.load( User.class, "1" );

// 等第二个进程执行

try {

sleep( 3000 );

} catch (InterruptedException e) {

e.printStackTrace();

}

userV1.setAge(new Integer(32));

tx.commit();

session.close();

}

public void run() {

testOptimisticLock();

}

public static void main(String[] args) {

// LockMain main = new LockMain();

// main.testPessimisticLock();

LockMain main1 = new LockMain();

main1.start();

LockMain main2 = new LockMain();

main2.start();

}

最后，执行测试主程序，在控制台中应该看到类似下面的输出：

Hibernate: select user0_.userId as userId0_0_, user0_.version as version0_0_, user0_.name as name0_0_, user0_.age as age0_0_ from USERINFO user0_ where user0_.userId=?

Hibernate: update USERINFO set version=?, name=?, age=? where userId=? and version=?

2006-10-3 21:27:20 org.hibernate.event.def.AbstractFlushingEventListener performExecutions

严重: Could not synchronize database state with session

org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [cn.hxex.hibernate.lock.User#1]

……

在Hibernate所执行的UPDATE语句中可以看到，version字段是作为更新的条件来执行的。对于第二个进程来说，由于数据库中的记录已经被第一个进程更新（更新的同时会导致version自动增加），就必然会导致第二个进程操作的失败。Hibernate正是利用这种机制来避免两次更新问题的出现。

posted on 2009-07-19 21:11 jadmin 阅读(158) 评论(0) 编辑收藏

常用链接

留言簿(1)

随笔档案(496)

搜索

最新评论

阅读排行榜

评论排行榜


只有注册用户登录后才能发表评论。




网站导航: 博客园 IT新闻知识库 C++博客博问