使用Memache 作为进程锁

<?php

// 使用Memache 作为进程锁 

class lock_processlock{

	// key 的前缀
	protected $sLockKeyPre;
	// 重试间隔
    protected $iLockRetryInterval;
	//重试次数
    protected $iLockRetryCount;
	//锁的过期时间
    protected $iLockCacheTimeout;
    // 锁过期后的回调函数
    protected $onLockTimeoutFunc;
	// memache 的实例
    protected $oMemcache;
	// 存储memcache失败后重试次数
    protected $iMemcacheRetryCount;

	  public function __construct ($onLockTimeoutFunc=NULL) {
        $aLockConfig = get_config('', 'lock');
        $this->sLockKeyPre = self::LOCK_KEY_PRE;
        $this->iLockRetryInterval = self::LOCK_RETRY_INTERVAL;
        $this->iLockRetryCount =self::LOCK_RETRY_COUNT;
        $this->iLockCacheTimeout = self::LOCK_CACHE_TIMEOUT;
        $this->iMemcacheRetryCount = self::LOCK_CACHE_TIMEOUT;
		if(!$onLockTimeoutFunc){
			// 如果加锁不成功则调用回调函数,如果没有回调函数,使用本类中所带的
			$onLockTimeoutFunc ='onLockTimeout' ;
		}
        $this->onLockTimeoutFunc = $onLockTimeoutFunc;
    }

	/**
	连接memcache 服务器
	*/
	public  function connect() {
		if (! isset ( $this->oMemcache )) {
			$this->oMemcache = new Memcache ();
			$this->oMemcache->connect ( '127.0.0.1', 11211 );
		}
		return $this->oMemcache;
	}

	/*
	向MeMcache中添加 key
	*/
	public addMemcache($sKey, $sValue, $iTimeout){

		for($i= 0 ; $i<$this->iMemcacheRetryCount){
			$bRes = $this->oMemcache->add($sKey, $sValue, $iTimeout);
			if($bRes){
				return true ;
			}
				// 如果加锁不成功,sleep 之后,从新加锁
			usleep($this->iLockRetryInterval*1000);

		}
		return  false ;  

	}

	/*
	加锁
	*/
	public function lock($sLockID){

		$oMemcache =   $this->connect();
	    $sKey = $this->sLockKeyPre . $sLockID;

		// 加锁如果不成功可以多试几次 

		for($i = 0 ; $i <$this->iLockRetryCount ; $i++){

			// 这里设置value 的值可以随便设置
			if($this->addMemcache($sKey,'1',$this->iLockCacheTimeout)){
				return true ;
			}

			// 如果加锁不成功,sleep 之后,从新加锁
			usleep($this->iLockRetryInterval*1000);

		}

		// 若还不成功,则加锁失败,调用回调函数,.也就是失败后需要处理的操作
		if(is_callable($this->onLockTimeoutFunc)){
			// 调用函数
			call_user_func($this->onLockTimeoutFunc);
		}

	}

	/*
	解锁操作
	*/
	public function unlock($sLockID){

		$oMemcache =   $this->connect();
	    $sKey = $this->sLockKeyPre . $sLockID;
		// 删除key
		return $this->oMemcache->delete($sKey);

	}

	/**
	如果加锁不成功,则执行如下操作
	*/
	 public function onLockTimeout(){

		 echo ("加锁超时");
	 }

}

// 应用实例 

  $oLock = new lock_processlock();
  $lockResource = "test";
  // 加锁
  $oLock->lock($lockResource);
  // 解锁
  $oLock->unlock($lockResource);

时间: 2024-07-30 09:29:22

使用Memache 作为进程锁的相关文章

crontab使用进程锁解决冲突

想到一个问题,如果在crontab里有个定时任务设置为一分钟执行一次,但是它执行的时间可能会超过一分钟,此时crontab一分钟后会再次运行该脚本吗?这样会不会出现冲突呢?网上找了下,说可以用Linux中的进程锁控制crontab执行的并发问题. 给一个shell脚本加锁,使用flock命令. 一般格式:flock [-sxun][-w #] fd#flock [-sxon][-w #] file [-c] command... 常用选项:-s, --shared :获得一个共享的锁.-x, -

Python进程锁和进程池

进程锁 进程与进程之间是独立的,为何需要锁? 对于进程,屏幕的输出只有一个,此时就涉及到资源的竞争.在Linux的Python2.x中可能出现问题. 这仅仅是一种情况,多个进程之间虽然是独立的,但仅限于内存和运算,如果涉及到其它一些资源, 就可能存在竞争问题,在实际使用过程中要注意思考和防范错误. from multiprocessing import Process, Lock def func(lock, i):     lock.acquire()     print("hello,&qu

进程锁

这里的进程锁与线程锁.互斥量.读写锁和自旋锁不同,它是通过记录一个PID文件,避免两个进程同时运行的文件锁.进程锁的作用之一就是可以协调进程的运行,例如crontab使用进程锁解决冲突提到,使用crontab限定每一分钟执行一个任务,但这个进程运行时间可能超过一分钟,如果不用进程锁解决冲突的话两个进程一起执行就会有问题.后面提到的项目实例Run也有类似的问题,通过进程锁可以解决进程间同步的问题.使用PID文件锁还有一个好处,方便进程向自己发停止或者重启信号.Nginx编译时可指定参数 --pid

PHP进程锁

<?php /** * CacheLock 进程锁,主要用来进行cache失效时的单进程cache获取,防止过多的SQL请求穿透到数据库 * 用于解决PHP在并发时候的锁控制,通过文件/eaccelerator进行进程间锁定 * 如果没有使用eaccelerator则进行进行文件锁处理,会做对应目录下产生对应粒度的锁 * 使用了eaccelerator则在内存中处理,性能相对较高 * 不同的锁之间并行执行,类似mysql innodb的行级锁 * 本类在sunli的phplock的基础上做了少许

python基于mysql实现的简单队列以及跨进程锁

在我们做多进程应用开发的过程中,难免会遇到多个进程访问同一个资源(临界资源)的状况,必须通过加一个全局性的锁,来实现资源的同步访问(同一时间只能有一个进程访问资源). 举个例子: 假设我们用mysql来实现一个任务队列,实现的过程如下: 1. 在Mysql中创建Job表,用于储存队列任务,如下: create table jobs( id auto_increment not null primary key, message text not null, job_status not null

一句话说清分布式锁,进程锁,线程锁

在分布式集群系统的开发中,线程锁往往并不能支持全部场景的使用,必须引入新的技术方案分布式锁. 线程锁:大家都不陌生,主要用来给方法.代码块加锁.当某个方法或者代码块使用锁时,那么在同一时刻至多仅有有一个线程在执行该段代码.当有多个线程访问同一对象的加锁方法/代码块时,同一时间只有一个线程在执行,其余线程必须要等待当前线程执行完之后才能执行该代码段.但是,其余线程是可以访问该对象中的非加锁代码块的. 进程锁:也是为了控制同一操作系统中多个进程访问一个共享资源,只是因为程序的独立性,各个进程是无法控

进程锁和共享池

一.进程锁 from multiprocessing import Process,Lock def lock_f(l,i): l.acquire() try: print ("multip - %s" % i ) finally: l.release() if __name__=="__main__": lock = Lock() for num in range(10): Process(target=lock_f,args = (lock,num)).star

python:多进程,多进程队列,多进程管道,Manager,进程锁,进程池

#!usr/bin/env python# -*- coding:utf-8 -*- __author__ = "Samson" import multiprocessingimport time def run(name): time.sleep(2) print("process start...%s" % name)if __name__ == "__main__": for i in range(10): p = multiprocess

13.1、多进程:进程锁Lock、信号量、事件

进程锁: 为什么要有进程锁:假如现在有一台打印机,qq要使用打印机,word文档也要使用打印机,如果没有使用进程锁,可能会导致一些问题,比如QQ的任务打印到一半,Word插进来,于是打印出来的结果是各自一半. 进程锁的创建与使用: 1.导入模块,from multiprocessing import Lock 2.创建锁对象:lock=Lock() 3.在需要锁的地方:lock.acquire() 4.在释放的地方:lock.release() from multiprocessing impo