Sharing of operation classes using Memache as process lock in PHP_PHP tutorial

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

//Use Memache as process lock

class lock_processlock{

//key prefix

protected $sLockKeyPre;

//Retry interval

protected $iLockRetryInterval;

//Number of retries

protected $iLockRetryCount;

//Lock expiration time

protected $iLockCacheTimeout;

//Callback function after lock expiration

protected $onLockTimeoutFunc;

//Instance of memache

protected $oMemcache;

//Number of retries after failure to store 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){

// If the lock is unsuccessful, call the callback function. If there is no callback function, use the

$onLockTimeoutFunc ='onLockTimeout' ;

}

$this->onLockTimeoutFunc = $onLockTimeoutFunc;

}

/**

Connect memcache server

*/

public function connect() {

if (! isset ( $this->oMemcache )) {

$this->oMemcache = new Memcache ();

$this->oMemcache->connect ( '127.0.0.1', 11211 );

}

return $this->oMemcache;

}

/*

Add key to MeMcache

*/

public addMemcache($sKey, $sValue, $iTimeout){

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

$bRes = $this->oMemcache->add($sKey, $sValue, $iTimeout);

if($bRes){

return true ;

}

// If the lock is unsuccessful, re-lock after sleep

usleep($this->iLockRetryInterval*1000);

}

return false ;

}

/*

Lock

*/

public function lock($sLockID){

$oMemcache = $this->connect();

$sKey = $this->sLockKeyPre . $sLockID;

// If the lock is unsuccessful, you can try a few more times

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

// The value set here can be set at will

if($this->addMemcache($sKey,'1',$this->iLockCacheTimeout)){

return true ;

}

// If the lock is unsuccessful, re-lock after sleep

usleep($this->iLockRetryInterval*1000);

}

// If it is still unsuccessful, the locking fails and the callback function is called, which is the operation that needs to be processed after the failure

if(is_callable($this->onLockTimeoutFunc)){

//Call function

call_user_func($this->onLockTimeoutFunc);

}

}

/*

Unlock operation

*/

public function unlock($sLockID){

$oMemcache = $this->connect();

$sKey = $this->sLockKeyPre . $sLockID;

//Delete key

return $this->oMemcache->delete($sKey);

}

/**

If the locking is unsuccessful, perform the following operations

*/

public function onLockTimeout(){

echo ("lock timeout");

}

}

//Application Example

$oLock = new lock_processlock();

$lockResource = "test";

// Lock

$oLock->lock($lockResource);

// Unlock