集群环境下防止并发的一种实现

听老歌

集群环境下防止并发的一种实现

        近来研究定时器Quartz集群的实现原理时，发现了一种利用数据库锁的方式来实现集群环境下进行并发控制的方式。由于现在的系统多是部署在集群环境中，需要进行并发控制时，这是一种很好的实现方法，现将原理介绍如下：



        首先，在数据库中建立一张拥有锁标识的表，建立表的SQL语句如下：

        CREATE TABLE TB_LOCKS

Sql代码

1. 1.(   LOCK_NAME VARCHAR2(40) NOT NULL,   
   
2. 2.IMARY KEY (LOCK_NAME）   
   
3. 3.)  
   
4.    (        LOCK_NAME VARCHAR2(40) NOT NULL,
   
5.         PRIMARY KEY (LOCK_NAME）
   
6.    )   

复制代码

表创建好之后，插入一些数据， 这些数据是根据数据库的业务逻辑操作抽象出的系统所拥有的表的类型，如"TRIGGER_ACCESS"就表示对任务触发器相关的信息进行修改删除操作时所需要获得的锁。每当要进行与某种业务相关的数据库操作时，先去这张表中查询操作相关的业务对象所需要的锁，如Quartz中需要修改触发气的状态，下次触发时间时，就需要获得"TRIGGER_ACCESS"所表示的锁。这时，执行查询这个表数据的SQL形如“select * from TB_LOCKS t where t.lock_name='TRIGGER_ACCESS' for update”，在select之后加了“for update”，就如JAVA语言中的为方法加上Symchriozed一样，起到了串形化访问修改所需数据的作用。当一个线程使用上述的SQL对表中的数据执行查询操作时，若查询结果中包含相关的行，数据库就会对这些行进行ROW LOCK。若此时又有另外一个线程使用相同的SQL对表的数据进行查询时，由于查询出的数据行已经被数据库锁住了，此时这个线程就只能等待，直到拥有这些行锁的线程完成了相关的业务操作，执行了commit动作后，数据库才会释放了相关行的锁，这个线程才能继续执行。通过这样的机制，在集群环境下，结合乐观锁的机制就可以防止一个线程对数据库数据的操作的结果被另外一个线程所覆盖，从而可以避免一些难以觉察的错误发生。当然，达到这种效果的前提是需要把Connection设置为手动提交，即autoCommit为false,下面是执行相关步骤的程序代码：



Java代码

1. 1./**  
   
2. 2.     * Execute the given callback having optionally aquired the given lock.  
   
3. 3.     * This uses the non-managed transaction connection.  
   
4. 4.     *   
   
5. 5.     * @param lockName The name of the lock to aquire, for example   
   
6. 6.     * "TRIGGER_ACCESS".  If null, then no lock is aquired, but the  
   
7. 7.     * lockCallback is still executed in a non-managed transaction.   
   
8. 8.     */      
   
9. 9.protected Object executeInNonManagedTXLock(   
   
10. 10.            String lockName,   
    
11. 11.            TransactionCallback txCallback) throws JobPersistenceException {   
    
12. 12.        boolean transOwner = false;   
    
13. 13.        Connection conn = null;   
    
14. 14.        try {   
    
15. 15.            if (lockName != null) {   
    
16. 16.                if (getLockHandler().requiresConnection()) {   
    
17. 17.                    conn = getNonManagedTXConnection();   
    
18. 18.                }   
    
19. 19.                //获得相关的锁，通过带有"for update"的select语句实现，如果这个锁被其他线程占用，执行这个操作的线程只能等待   
    
20. 20.                transOwner = getLockHandler().obtainLock(conn, lockName);   
    
21. 21.            }   
    
22. 22.               
    
23. 23.            if (conn == null) {   
    
24. 24.                conn = getNonManagedTXConnection();   
    
25. 25.            }   
    
26. 26.               
    
27. 27.            Object result = txCallback.execute(conn)；//执行相关的业务逻辑操作，获得操作的结果   
    
28. 28.            commitConnection(conn);//提交操作结果，释放锁   
    
29. 29.            return result;   
    
30. 30.        } catch (JobPersistenceException e) {   
    
31. 31.            rollbackConnection(conn);//撤销操作结果，释放锁   
    
32. 32.            throw e;   
    
33. 33.        } catch (RuntimeException e) {   
    
34. 34.            rollbackConnection(conn);//撤销操作结果，释放锁   
    
35. 35.            throw new JobPersistenceException("Unexpected runtime exception: "  
    
36. 36.                    + e.getMessage(), e);   
    
37. 37.        } finally {   
    
38. 38.            try {   
    
39. 39.                releaseLock(conn, lockName, transOwner);   
    
40. 40.            } finally {   
    
41. 41.                cleanupConnection(conn);   
    
42. 42.            }   
    
43. 43.        }   
    
44. 44.    }   
    
45. 45.      

复制代码

lastfile

学习学习