Oracle EBS 并发请求不兼容（程序逻辑不兼容）

通常一个并发请求的不兼容性通过程序设定即可，但是有很多情况仅仅通过程序的不兼容，无法做到处理内容的不兼容。

比如有这样一个需求场景，需要EBS加工所有单位的数据和外围系统对接：

1. 定时全量计算数据；

2. 我们不能每家单位修改都全量计算所有单位数据，效率跟不上；

2. 不能重复计算（全量计算的时候，单家公司的计算和全量一起计算就会存在重复的情况）

这三个要求同时满足的方案有很多种，就开发简便的角度来说，全量计算和单个公司计算逻辑上只有参数范围差异，所以很多时候我们会选择一套源码一套架构。这个时候就不得不考虑重复计算问题。当全量计算的时候，单个单位不能进行计算防止重复计算。这个时候Oracle EBS 标准的程序（并发请求）是无法做到按参数范围控制兼容性，所以就需要我们人为的在逻辑上进行不兼容锁。

本文主要基于上述逻辑解释逻辑上的不兼容常规做法，主角【dbms_lock】包的使用。

先看一下创建锁的写法：

PROCEDURE lock_request
(
  p_lock_name   IN VARCHAR2,
  x_lock_status OUT VARCHAR2,
  x_lock_handle OUT VARCHAR2
) IS
  l_lock_handle   VARCHAr2(128); --锁定句柄
  l_call_status   VARCHAr2(1);
  l_realse_status NUMBER;
BEGIN
  --打开dbms_lock 的包头 ，仔细阅读说明

    --方法1,注意这个方法会自动commit ,他会在创建锁的时候对当前事务进行提交。
       
    dbms_lock.allocate_unique(lockname   => p_lock_name,
                              lockhandle => l_lock_handle);
  
    --方法2,自治事务 提交（建议使用)，但是不同的版本可能没有，要看数据库版本，必要的时候可以向metalink 要安装包安装。
    
    
   --建议使用方法2，但是方法2需要系统版本支持才行。

  --  Return value:
  --    0 - success
  --    1 - timeout
  --    2 - deadlock
  --    3 - parameter error
  --    4 - already own lock specified by 'id' or 'lockhandle'
  --    5 - illegal lockhandle                                       
  l_call_status := dbms_lock.request(lockhandle        => l_lock_handle,
                                     lockmode          => dbms_lock.x_mode, --锁定模式
                                     timeout           => 30, --秒数，表示等待上一个锁释放的时间，如果上一个锁在等待的时间内没释放，则锁不上，本次将不继续执行。
                                     release_on_commit => FALSE);

  x_lock_status := l_call_status;
  x_lock_handle := l_lock_handle;
END lock_request;

有锁就要解锁：

  PROCEDURE release_request(p_lock_handle IN VARCHAR2) IS
    l_realse_status NUMBER;
  BEGIN
    l_realse_status := dbms_lock.release(p_lock_handle);
  END release_request;

使用示例：

CREATE OR REPLACE PROCEDURE lock_test
(
  x_errormsg OUT VARCHAR2
) IS
  l_lock_name   VARCHAr2(100);
  l_lock_status VARCHAr2(10);
  l_lock_handle VARCHAr2(128);
  PROCEDURE lock_request
  (
    p_lock_name   IN VARCHAR2,
    x_lock_status OUT VARCHAR2,
    x_lock_handle OUT VARCHAR2
  ) IS
    l_lock_handle   VARCHAr2(128); --锁定句柄
    l_call_status   VARCHAr2(1);
    l_realse_status NUMBER;
  BEGIN
    --打开dbms_lock 的包头 ，仔细阅读说明
  
    --这个方法会自动commit 注意,他会在创建锁的时候对当前事务进行提交。
    --建议使用方法2，但是方法2需要系统版本支持才行。
    --方法1
    dbms_lock.allocate_unique(lockname   => p_lock_name,
                              lockhandle => l_lock_handle);
  
    --自治事务 提交（建议使用)
    --方法2
    
    --  Return value:
    --    0 - success
    --    1 - timeout
    --    2 - deadlock
    --    3 - parameter error
    --    4 - already own lock specified by 'id' or 'lockhandle'
    --    5 - illegal lockhandle                                       
    l_call_status := dbms_lock.request(lockhandle        => l_lock_handle,
                                       lockmode          => dbms_lock.x_mode, --锁定模式
                                       timeout           => 10, --秒数
                                       release_on_commit => FALSE);
  
    x_lock_status := l_call_status;
    x_lock_handle := l_lock_handle;
  END lock_request;
  PROCEDURE release_request(p_lock_handle IN VARCHAR2) IS
    l_realse_status NUMBER;
  BEGIN
    l_realse_status := dbms_lock.release(p_lock_handle);
  END release_request;

BEGIN
  l_lock_name := 'lock_name'; --锁名称， 做文章的地方，锁是根据名称进行检查，所以名称可以大做文章来进行锁的控制
  --使用
  lock_request(l_lock_name, l_lock_status, l_lock_handle);
  IF l_lock_status = '0' THEN
    dbms_lock.sleep(100); --模拟程序运行，让程序停在这里100秒
  ELSE
    x_errormsg := '有人在处理记录，请稍后再试';
    RAISE fnd_api.g_exc_error;
  END IF;

  IF l_lock_status = 0 THEN
    release_request(l_lock_handle);
  END IF;
EXCEPTION
  WHEN fnd_api.g_exc_error THEN
    IF l_lock_status = 0 THEN
      release_request(l_lock_handle);
    END IF;
  WHEN OTHERS THEN
    IF l_lock_status = 0 THEN
      release_request(l_lock_handle);
    END IF;
  
END;

开两个窗口进行实验：

等待上一个程序运行10秒后，无法上锁，就提示有人在操作，稍后再试，同样的原理搬到并发请求上实现程序的逻辑不兼容性。

以上，谢谢，欢迎大家指正

Oracle EBS 并发请求不兼容（程序逻辑不兼容）

Java相关栏目本月热门文章