Java使用FileLock实现Java进程互斥锁

原理:
JDK的nio包中FileLock实现类似Linux fcntl的文件锁, 可使文件被进程互斥访问.  借助此功能, 可以实现强大的Java进程互斥锁, 从而在应用层面保证同一时间只有惟一的Jar应用进程在运行! 避免某些因素导致jar重复执行, 多个进程产生竞争,破坏业务数据. (当然, 你可以借助类似ubuntu的upstart脚本或者ps -p <pid>之类的做法来做到相同的功能).
实现:

  1. package test;
  2. import java.io.File;
  3. import java.io.IOException;
  4. import java.io.RandomAccessFile;
  5. import java.nio.channels.FileChannel;
  6. import java.nio.channels.FileLock;
  7. import java.util.concurrent.Callable;
  8. import java.util.concurrent.TimeUnit;
  9. public class FileLockTest {
  10. public static void main(String[] args) throws Exception {
  11. exclusiveWithFileLock(new Callable<Void>() {
  12. @Override
  13. public Void call() throws Exception {
  14. TimeUnit.SECONDS.sleep(10); // 使用休眠模拟业务逻辑
  15. return null;
  16. }
  17. });
  18. }
  19. public static <V> V exclusiveWithFileLock(Callable<V> caller)
  20. throws Exception {
  21. File lockFile = new File("/tmp/"+FileLockTest.class.getCanonicalName());//使用类名做为文件名称
  22. if (!lockFile.exists()) {
  23. if (!lockFile.getParentFile().exists()) {
  24. lockFile.getParentFile().mkdirs();
  25. }
  26. if (!lockFile.createNewFile()) {
  27. throw new IOException("create lock file failed! ");
  28. }
  29. }
  30. FileChannel fc = null;
  31. try {
  32. fc = new RandomAccessFile(lockFile,"rw").getChannel();
  33. FileLock lck = fc.tryLock();
  34. if (lck == null) {
  35. System.out.println("File is lock by another programme");
  36. System.exit(1);
  37. } else {
  38. System.out.println("Do your work here...");
  39. return caller.call();
  40. }
  41. } finally {
  42. if (fc != null) {
  43. fc.close();
  44. }
  45. }
  46. return null;
  47. }
  48. }

复制代码

结果:

  1. [email protected]:~/myworkspace/source/jademo/src$ java test.FileLockTest
  2. File is lock by another programme
  3. [email protected]:~/myworkspace/source/jademo/src$ java test.FileLockTest
  4. Do your work here...

复制代码

优势:
1. 实现简单, 功能强大.

时间: 2024-11-09 09:32:34

Java使用FileLock实现Java进程互斥锁的相关文章

开启子进程的两种方式,孤儿进程与僵尸进程,守护进程,互斥锁,IPC机制,生产者与消费者模型

开启子进程的两种方式 # # # 方式一: # from multiprocessing import Process # import time # # def task(x): # print('%s is running' %x) # time.sleep(3) # print('%s is done' %x) # # if __name__ == '__main__': # # Process(target=task,kwargs={'x':'子进程'}) # p=Process(tar

Python并发编程03/僵尸孤儿进程,互斥锁,进程之间的通信

目录 Python并发编程03/僵尸孤儿进程,互斥锁,进程之间的通信 1.昨日回顾 2.僵尸进程和孤儿进程 2.1僵尸进程 2.2孤儿进程 2.3僵尸进程如何解决? 3.互斥锁,锁 3.1互斥锁的应用 3.2Lock与join的区别 4.进程之间的通信 进程在内存级别是隔离的 4.1基于文件通信 (抢票系统) 4.2基于队列通信 Python并发编程03/僵尸孤儿进程,互斥锁,进程之间的通信 1.昨日回顾 1.创建进程的两种方式: 函数, 类. 2.pid: os.getpid() os.get

10.22进程互斥锁,队列,堆栈,线程

进程互斥锁 让并发变成串行,牺牲了执行效率,保证了数据的安全. 在程序并发执行时,如果需要修改数据就使用互斥锁. 队列 相当于内存中的空间. 可以存放多个数据,必须排队,遵循先进先出的顺序. from multiprocessing import Queue #调用队列类,实例化队列对象q q = Queue(5) #若传参,队列中就可以存放5个数据 q = Queue() #若不传参,则队列中可以存放无限个数据 q.get() #获取数据 q.put() #添加数据,满了就报错 q.empty

解决NSDistributedLock进程互斥锁的死锁问题(二)

上一篇文章中介绍了采用了文件记录锁来实现更加安全的多进程互斥,它的平台兼容性也非常好,并且我们也采用它实现了NSDistributedLock的所有的方法.其实在OSX还可以采用文件读写锁来实现更加方便的进程互斥,在fcntl.h中我们可以看到这样的宏定义: 123 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)#define O_SHLOCK 0x0010 /* open with shared file lock */#d

解决NSDistributedLock进程互斥锁的死锁问题(一)

在MAC下的多进程开发中,NSDistributedLock是一个非常方便的互斥锁解决方案,一般的使用方法: 12345678 NSDistributedLock *lock = [[NSDistributedLock alloc] initWithPath:@"/Users/mac/Desktop/lock.lock"];while (![lock tryLock]){ sleep(1);} //do something[lock unlock]; 但在实际使用过程中,当执行到do

守护进程,互斥锁,IPC,队列,生产者与消费者模型

小知识点:在子进程中不能使用input输入! 一.守护进程 守护进程表示一个进程b 守护另一个进程a 当被守护的进程结束后,那么守护进程b也跟着结束了 应用场景:之所以开子进程,是为了帮助主进程完成某个任务,然而,如果主进程认为自己的事情一旦做完了就没有必要使用子进程了,就可以将子进程设置为守护进程 例如:在运行qq的过程,开启一个进程,用于下载文件,然而文件还没有下载完毕,qq就退出了,下载任务也应该跟随qq的退出而结束. from multiprocessing import Process

35 守护进程 互斥锁 IPC 共享内存 的方式 生产者消费者模型

守护进程 进程:一个正在运行的程序. 主进程创建守护进程: 1.守护进程会在主进程代码执行结束后就终止, 2.守护进程内无法再开启子进程,否则抛出异常. 注意:进程之间是互相独立的,主进程代码运行结束,守护进程随即终止. 例子:from multiprocessing import Processimport time def task(): print('老了....') time.sleep(2) print('睡了一会..') if __name__ == '__main__': prin

python并发编程-进程理论-进程方法-守护进程-互斥锁-01

操作系统发展史(主要的几个阶段) 初始系统 1946年第一台计算机诞生,采用手工操作的方式(用穿孔卡片操作) 同一个房间同一时刻只能运行一个程序,效率极低(操作一两个小时,CPU一两秒可能就运算完了) 联机批处理系统 脱机批处理系统 多道程序系统 1.空间上的复用 ? 多个程序公用一套计算机硬件 2.时间上的复用 ? 切换+保存状态 ? 保存状态:保存当前的运行状态,下次接着该状态继续执行 ? 切换的两种情况 ? (1) 当一个程序遇到 I/O 操作(不需要使用CPU),操作系统会剥夺该程序的C

进程 &gt;&gt; 互斥锁、队列与管道、生产者消费者模型

目录 1.互斥锁 2.队列与管道 3.生产者消费者模型(Queue) 4.生产者消费者模型(JoinableQueue) 1.互斥锁 首先导入Lock模块 实例化一把锁 但是每次生成子进程的时候都会重新实例化一把锁,我们的目的是想让所有的子进程使用同一把锁,所以需要把锁传递给子进程在使用 锁名.acquire():开锁->所有子进程开始抢位置 锁名.release():关锁->位置排好了,开始执锁起来执行. join与互斥锁的区别:join是把所有的子进程代码变为串行的,而互斥锁则可以规定那几