如何让并发程序互斥的几种方法

本文介绍三种Oracle环境下实现并发控制的方法:一是通过并发程序定义界面设置全局互斥;二是利用DBMS_LOCK标准包实现灵活锁定;三是查询当前运行请求并根据业务需求决定是否继续执行。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

 

方法一:在并发程序定义界面将并发程序定义成互斥的,但是该种互斥方法是全局的,也就是说任何情况下该请求同一时间都只能跑一个,这样的话有些业务就不能满足了,比如只要求在同一个OU下不能并发,定义界面如下:



  

 

方法二:使用DBMS_LOCK这个标准包,该方法非常灵活,几乎可以满足所有的业务需求,但是该方法只能在有apps权限的情况下使用,所有如果当权限不足是则不适用了,下面就以同一个OU下不能并发为例,做个小例子:

 

DECLARE
  -- lock
  l_lockname    VARCHAR2(100);
  l_lockhandle  VARCHAR2(200);
  l_lock_output NUMBER;
  l_locked      BOOLEAN := FALSE;
  g_pkg_name    VARCHAR2(240) := 'test_package';
  g_org_id      NUMBER := 125;
BEGIN
  /* 定义按何种方式并发(此处为同一个OU不能同时执行)
  * lockname类似于定义一个唯一的名字,当并发程序执行时就会去判断是否这个唯一标识已经存在*/
  l_lockname := g_pkg_name || '_' || g_org_id;
  --根据l_lockname获取唯一标识l_lockhandle
  dbms_lock.allocate_unique(lockname   => l_lockname,
                            lockhandle => l_lockhandle);
 
  /*用l_lockhandle这个唯一标识去给当前请求加锁
  --  Return value:
  --    0 - success
  --    1 - timeout
  --    2 - deadlock
  --    3 - parameter error
  --    4 - already own lock specified by 'id' or 'lockhandle'
  --    5 - illegal lockhandle*/
  l_lock_output := dbms_lock.request(l_lockhandle,
                                     6,
                                     60,
                                     FALSE);
 
  IF l_lock_output <> 0 THEN
    --Output lock failure message
    RAISE apps.fnd_api.g_exc_error;
  END IF;
 
  --此处添加请求的业务逻辑
  --dbms_lock.sleep(seconds => 50);
 
  /*特别注意的是一定要将lockname释放掉 否则这个并发就永远别想再执行了*/
  IF l_lock_output = 0 THEN
    l_lock_output := dbms_lock.release(l_lockhandle);
  END IF;
EXCEPTION
  WHEN apps.fnd_api.g_exc_error THEN
    IF l_lock_output = 0 THEN
      l_lock_output := dbms_lock.release(l_lockhandle);
    END IF;
  WHEN OTHERS THEN
    IF l_lock_output = 0 THEN
      l_lock_output := dbms_lock.release(l_lockhandle);
    END IF;
END;

 

方法三:在相应业务条件下查询当前是否有正在运行的请求,如果有则退出或等待,该方法一定要根据实际业务情况来判断是否能使用,还是以同一个OU下不能并发为例:

SELECT COUNT(1)
  INTO l_count_request
  FROM apps.fnd_concurrent_programs fcp, 
       apps.fnd_concurrent_requests fcr
 WHERE 1 = 1
   AND fcp.application_id = fcr.program_application_id
   AND fcp.concurrent_program_id = fcr.concurrent_program_id
   AND fcp.concurrent_program_name = 'CUXTEST'
   AND fcr.request_id <> apps.fnd_global.conc_request_id
   AND fcr.argument1 = p_org_id
   AND fcr.phase_code = 'R';
 
IF l_count_request > 0 THEN
  RAISE apps.fnd_api.g_exc_error;
END IF;

 

 

### Java 中线程同步与互斥的多种实现方法 #### synchronized 关键字 `synchronized` 是一种基本的互斥实现方法,能够修饰方法或代码块,确保同一时刻只有一个线程能访问被保护的资源或执行特定代码段。当一个线程进入由 `synchronized` 修饰的方法或代码块时,会自动获得对象锁,在退出该区域时释放此锁。 ```java public class SynchronizedExample { private int count = 0; public synchronized void increment() { count++; } public static void main(String[] args) throws InterruptedException { SynchronizedExample example = new SynchronizedExample(); Runnable task = () -> { for (int i = 0; i < 1000; i++) { example.increment(); } }; Thread t1 = new Thread(task); Thread t2 = new Thread(task); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println("Final Count: " + example.count); } } ``` 这种方法简单易用,但是灵活性较低[^1]。 #### ReentrantLock 类 除了 `synchronized` 外,Java 还提供了 `ReentrantLock` 来实现更灵活的锁定机制。相比前者,后者允许显式地控制锁的行为,比如设置超时尝试获取锁、支持公平策略等特性。需要注意的是,使用此类需谨慎处理异常情况下的解锁逻辑以免造成死锁等问题。 ```java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockExample { private final Lock lock = new ReentrantLock(true); // true 表示启用公平模式 private int value = 0; public void add(int num) { try { lock.lockInterruptibly(); // 可响应中断请求 value += num; } catch (InterruptedException e) { throw new RuntimeException(e.getMessage()); } finally { lock.unlock(); } } public static void main(String[] args) { LockExample le = new LockExample(); // 测试并发调用... } } ``` 这种方式虽然增加了编码难度,但在某些情况下可以带来更好的性能表现以及更多的功能选项[^4]。 #### 原子类(Atomic Classes) 对于简单的计数器或其他数值类型的更新操作来说,利用 `java.util.concurrent.atomic` 包中的原子类往往是最优的选择之一。这类工具内部实现了高效的无锁算法,从而避免了传统加锁所带来的开销并提高了程序的整体吞吐量。 ```java import java.util.concurrent.atomic.AtomicInteger; public class AtomicExample { private AtomicInteger atomicInt = new AtomicInteger(0); public void increase() { while (true) { int current = atomicInt.get(); boolean successful = atomicInt.compareAndSet(current, current + 1); if (successful) break; } } public static void main(String[] args) { AtomicExample ae = new AtomicExample(); // 并发测试... } } ``` 上述三种方案各有千秋,开发者应根据实际需求选择最适合的一种或几种组合起来解决问题[^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值