flock

(PHP 4, PHP 5)

flockПортируемая консультативная блокировка файлов

Описание

bool flock ( resource $handle , int $operation [, int &$wouldblock ] )

flock() позволяет осуществить простую модель чтения/записи, которая может быть использована практически на любой платформе (включая большинство вариантов Unix и даже Windows).

В версиях PHP до 5.3.2 блокировка освобождалась также вызовом функции fclose() (которая также вызывается автоматически по завершении скрипта).

PHP поддерживает портируемый способ консультативной блокировки (adviosory locking) полностью всего файла (что означает, что все программы, осуществляющие доступ к файлу, должны использовать один и тот же способ блокировки, иначе блокировка не будет работать). По умолчанию, данная функция будет ждать получения блокировки; это поведение можно изменить (на платформах отличных от Windows) с помощью описанного ниже параметра LOCK_NB.

Список параметров

handle

Указатель (resource) на файл, обычно создаваемый с помощью функции fopen().

operation

operation может принимать следующие значения:

  • LOCK_SH для получения разделяемой блокировки (чтение).
  • LOCK_EX для получения эксклюзивной блокировки (запись).
  • LOCK_UN для снятия блокировки (разделяемой или эксклюзивной).

Также возможно добавить константу LOCK_NB в качестве битовой маски к любой из вышеуказанных операций, если вы не хотите ждать пока flock() получит блокировку. (не поддерживается в Windows)

wouldblock

Необязательный третий параметр будет установлен в TRUE, если блокировка будет блокирующей (код ошибки EWOULDBLOCK). (не поддерживается на Windows)

Возвращаемые значения

Возвращает TRUE в случае успешного завершения или FALSE в случае возникновения ошибки.

Список изменений

Версия Описание
5.3.2 Автоматическое снятие блокировки при закрытии было удалено. Снятие блокировки теперь всегда должно осуществляться вручную.
4.0.1 Добавлены константы LOCK_XXX. Ранее необходимо было использовать 1 вместо LOCK_SH, 2 вместо LOCK_EX, 3 вместо LOCK_UN и 4 вместо LOCK_NB

Примеры

Пример #1 Пример использования функции flock()

<?php

$fp 
fopen("/tmp/lock.txt""r+");

if (
flock($fpLOCK_EX)) { // выполняем эксклюзивную блокировку
    
ftruncate($fp0); // очищаем файл
    
fwrite($fp"Что-нибудь пишем сюда\n");
    
fflush($fp);        // очищаем вывод перед отменой блокировки
    
flock($fpLOCK_UN); // отпираем файл
} else {
    echo 
"Не удалось получить блокировку !";
}

fclose($fp);

?>

Пример #2 Использование flock() с параметром LOCK_NB

<?php
$fp 
fopen('/tmp/lock.txt''r+');

/* Включаем параметр LOCK_NB в операции LOCK_EX */
if(!flock($fpLOCK_EX LOCK_NB)) {
    echo 
'Не удалось получить блокировку';
    exit(-
1);
}

/* ... */

fclose($fp);
?>

Примечания

Замечание:

В Windows flock() использует обязательную (mandatory) блокировку вместо консультативной. Обязательная блокировка также поддерживается на Linux и операционных системах, основанных на System V с помощью стандартного механизма, который предоставляет системный вызов fcntl(): т.е. искомый файл должен иметь установленный бит доступа setgid и неустановленный бит группового выполнения. Для корректной работы этой схемы в Linux, файловая система также должна быть смонтирована с опцией mand.

Замечание:

Из-за того, что функции flock() необходим указатель на файл, вам может понадобиться воспользоваться специальным запирающим файлом для того, чтобы ограничить доступ к файлу, который вы намерены очищать, путём его открытия в режиме записи (используя "w" или "w+" в качестве аргумента функции fopen()).

Замечание:

Может быть использована только на дескрипторах локальных файлов, возвращенных функцией fopen(), или файловых дескрипторах пользовательских потоков, реализующих метод streamWrapper::stream_lock().

Внимание

Присвоение другого значения аргументу handle в последующем коде отменит существующую блокировку.

Внимание

В некоторых операционных системах flock() реализован на уровне процессов. При использовании многопоточных серверных API, таких как ISAPI, вы не можете полагаться на flock() для защиты ваших файлов от других PHP-скриптов, которые работают в параллельном потоке на том же сервере!

flock() не поддерживается на старых файловых системах вроде FAT и ее производных, так что всегда будет возвращать FALSE в этом окружении (это особенно касается пользователей Windows 98).

Коментарии

You should lock the file _before_ opening it, and unlock _after_ closing it. Othervise an another process might be able to access the file between the lock/unlock and the open/close operation.
2002-08-06 16:10:37
http://php5.kiev.ua/manual/ru/function.flock.html
I have found that if you open a currently locked file with 'w' or 'w+' ("file pointer at the beginning of the file and truncate the file to zero length")  then it will not truncate the file when the lock is released and the file available.

Example I used to test it:
<?php
// a.php
$fp fopen"/tmp/lock.txt""w+" );
flock$fpLOCK_EX ); // exclusive lock

$steps 10;
// write to the file
for ($i=0$i$steps$i++) {
   
fwrite($fp'a '.time().' test '$i."\n");
   
sleep(1);
}
flock$fpLOCK_UN ); // release the lock
fclose$fp );
?>

----------
<?php
// b.php

$fp fopen"/tmp/lock.txt""w+" );
flock$fpLOCK_EX ); // exclusive lock

// ftruncate($fp, 0) is needed here! <----

$steps 5;
// write to the file
for ($i=0$i$steps$i++) {
   
fwrite($fp'b '.time().' test '$i."\n");
   
sleep(1);
}
flock$fpLOCK_UN ); // release the lock
fclose$fp );
?>

Loading a.php then loading b.php right after will result in:
b 1054075769 test 0
b 1054075770 test 1
b 1054075771 test 2
b 1054075772 test 3
b 1054075773 test 4
a 1054075764 test 5
a 1054075765 test 6
a 1054075766 test 7
a 1054075767 test 8
a 1054075768 test 9

As you can see, b.php does not truncate the file as the w+ would suggest if the file were instantly available. But only moves the pointer to the begining of the file. If b.php was loaded after a.php finished then there would be no "a ..." lines in the file, since it would be truncated.

To fix this you have to add ftruncate($fp, 0) right after the flock.

'r+' and 'a' seem to work fine, though.
2003-05-27 21:12:12
http://php5.kiev.ua/manual/ru/function.flock.html
Автор:
If you don't want use secondary lock file while truncating, try this:

<?php

$fp 
fopen("/tmp/lock.txt""a+");

if (
flock($fpLOCK_EX)) { // do an exclusive lock
   
ftruncate($fp0);
   
fwrite($fp"Write something here\n");
   
flock($fpLOCK_UN); // release the lock
} else {
   echo 
"Couldn't lock the file !";
}

fclose($fp);

?>
2004-01-29 12:39:00
http://php5.kiev.ua/manual/ru/function.flock.html
Автор:
I'm thinking that a good way to ensure that no data is lost would be to create a buffer directory that could store the instructions for what is to be written to a file, then whenever the file is decidedly unlocked, a single execution could loop through every file in that directory and apply the indicated changes to the file.

I'm working on writing this for a flat-file based database.  The way it works is, whenever a command is issued (addline, removeline, editline), the command is stored in a flat file stored in a folder named a shortened version of the filename to be edited and named by the time and a random number.  In that file is a standardized set of commands that define what is to be done to what file (the likes of "file: SecuraLog/index_uid" new line "editline: 14").

Each execution will check every folder in that directory for files and a certain amount of time (I don't know how long, maybe 1-2 seconds) is spent making pending changes to unlocked files.  This way no changes will be lost (i.e. person 1 makes a change at the same time as person 2, and person 1 loses the race by just enough to have their changed version of the file overwritten by person 2's version) and there will be no problems with opening an empty open file.
2004-06-30 20:59:16
http://php5.kiev.ua/manual/ru/function.flock.html
Like a user already noted, most Linux kernels (at least the Redhat ones) will return false, even if you locked the file. This is because the lock is only ADVISORY (you can check that in /proc/locks). What you have to do there is to evalute the 3rd parameter of flock(), $eWouldBlock. See for an example below. Note however that if you
lock the file in non blocking mode, flock() will work as expected (and blocks the script).

<?php
                                                                               
$fp 
fopen"/var/lock/process.pid""a" );
if ( !
$fp || !flock($fp,LOCK_EX|LOCK_NB,$eWouldBlock) || $eWouldBlock ) {
 
fputsSTDERR"Failed to acquire lock!\n" );
  exit;
}
                                                                               
// do your work here
                                                                               
fclose$fp );
unlink"/var/lock/process.pid" );
                                                                               
?>
2004-09-08 06:31:56
http://php5.kiev.ua/manual/ru/function.flock.html
just wanted to say that you will most likely fail if you use a separate lock file together with register_shutdown_function.

my script did some different actions... resizing pictures, rotating them and this stuff. it needed a "database" file to get the correct file locations. this database file also stored some flags. and of course the script had to save that file when it was done.

because of my script exited on many different points depending on the action i used register_shutdown_function to save the file. it wanted to use a locking system to be sure the script doesn't overwrite the data another process had written into it some microseconds before. i was running on windows 2000 and apache2 on my developing machine, and flock always returned true for some reason... so i used a separate lock file. the script looked for it at the beginning and exited if it was found. otherwise it created it. but this file had to be deleted at the end. i put the unlink command into the registered shutdown-function but it never deleted the file. i tried clearstatcache and some other stuff but it didn't help.

maybe this helps someone.
2005-08-09 23:28:27
http://php5.kiev.ua/manual/ru/function.flock.html
I ran into a loop because I just checked for true (= you got the lock) as return value of flock() and tried again when I got a false.

<?php
   
function naive_wait_for_file($fp) {
        while (
true) {
            if (
flock($fpLOCK_EX)) {
                return;
            }
           
$k rand(020);
           
usleep(round($k 10000));  # k * 10ms
       
}
    }
?>

Unfortunately in one case the $fp I put in was invalid, so I always got false and got stuck.
Lesson: check if your $fp is valid before entering the loop, or look closer if you get a false.

<?php
   
function wait_for_file($fp) {
        if (
$fp === false) {
            return;
        }
        while (
true) {
            if (
flock($fpLOCK_EX)) {
                return;
            }
           
$k rand(020);
           
usleep(round($k 10000));  # k * 10ms
       
}
    }
?>
2006-02-15 04:00:08
http://php5.kiev.ua/manual/ru/function.flock.html
Indeed, flock() will not work reliably when the underlying filesystem is NFS. The proper way to perform file locking, in this case, would be to use PHP's link() function. From the Linux man page of open():

       O_EXCL When used with O_CREAT, if the file  already  exists  it  is  an
              error  and  the open will fail. In this context, a symbolic link
              exists, regardless of where its points to.  O_EXCL is broken  on
              NFS file systems, programs which rely on it for performing lock-
              ing tasks will contain a race condition.  The solution for  per-
              forming  atomic  file  locking  using  a lockfile is to create a
              unique file on the same fs  (e.g.,  incorporating  hostname  and
              pid),  use  link(2)  to  make  a link to the lockfile. If link()
              returns 0, the lock is successful.  Otherwise,  use  stat(2)  on
              the  unique  file to check if its link count has increased to 2,
              in which case the lock is also successful.
2006-08-14 12:30:57
http://php5.kiev.ua/manual/ru/function.flock.html
Автор:
I've been testing a few custom file access functions but I always liked the simplicity of file_get_contents(). Of course it doesn't seem to respect any file locks created with flock(). I created the function below to wrap around file_get_contents() so it can support locked files. It's an odd way of doing it but it works for me.

<?php
function flock_get_contents($filename){

   
$return FALSE;

    if(
is_string($filename) && !empty($filename)){
        if(
is_readable($filename)){
            if(
$handle = @fopen($filename'r')){
                while(!
$return){
                    if(
flock($handleLOCK_SH)){
                        if(
$return file_get_contents($filename)){
                           
flock($handleLOCK_UN);
                        }
                    }
                }
               
fclose($handle);
            }
        }
    }
   
    return 
$return;
}
?>
2007-03-27 19:52:07
http://php5.kiev.ua/manual/ru/function.flock.html
Автор:
The supplied documentation is vague, ambiguous and lacking, and the user comments contain erroneous information! The flock function follows the semantics of the Unix system call bearing the same name. Flock utilizes ADVISORY locking only; that is, other processes may ignore the lock completely; it only affects those that call the flock call.

LOCK_SH means SHARED LOCK. Any number of processes MAY HAVE A SHARED LOCK simultaneously. It is commonly called a reader lock.

LOCK_EX means EXCLUSIVE LOCK. Only a single process may possess an exclusive lock to a given file at a time.

If the file has been LOCKED with LOCK_SH in another process, flock with LOCK_SH will SUCCEED. flock with LOCK_EX will BLOCK UNTIL ALL READER LOCKS HAVE BEEN RELEASED.

If the file has been locked with LOCK_EX in another process, the CALL WILL BLOCK UNTIL ALL OTHER LOCKS have been released.

If however, you call flock on a file on which you possess the lock, it will try to change it. So: flock(LOCK_EX) followed by flock(LOCK_SH) will get you a SHARED lock, not "read-write" lock.
2007-10-06 06:41:36
http://php5.kiev.ua/manual/ru/function.flock.html
Автор:
Further information on flock: The system is not restarted if a signal is delivered to the process, so flock will happily return false in case of SIGALRM, SIGFPE or something else.
2007-10-06 07:30:33
http://php5.kiev.ua/manual/ru/function.flock.html
Just a comment about the last method to lock files using filemtime().
What if   filemtime($fp[1]) == $fp[3]   because somebody modified the file less than 1s after the value of $fp[3] was picked up?
Then this modification will be lost...? 

This system to lock files is made to prevent problems when two modifications are so close that they can interfere, so the case "less than 1s" will often happen?

However, lose some modifications is better than spoil all the file...
2007-12-07 05:48:42
http://php5.kiev.ua/manual/ru/function.flock.html
I have noticed that if you change the value of your fopen ressource, the lock is working no longer..

<?php

$fo 
fopen('lockfile.txt','a');

flock($fo,LOCK_EX);

$fo '';

// Lock is disable

?>
2007-12-19 09:56:20
http://php5.kiev.ua/manual/ru/function.flock.html
besides from what the manual says about locking a file opendend in w or w+ and using a special lock file for these cases, you should simply truncate the file yourself with ftruncate() after writing:

<?php

$data
='some data';
$handle=fopen('file','r+');
flock($handle,LOCK_EX);
fwrite($handle,$data);
ftruncate($handle,ftell($handle));
flock($handle,LOCK_UN);
fclose($handle);

?>

now the file will have the size of $data without opening the file in w mode but with a lock on the file.

to the previous writers jpriebe and mallory:
of course the lock is lost in this case, but thats simply because the file is closed by PHP. and closing the file means unlocking it (same as when you use fclose() yourself).
2007-12-23 21:05:17
http://php5.kiev.ua/manual/ru/function.flock.html
I just want to add a note about making atomic lock on NFS, there is only two
ways:

- 1 (the most robust but the most complicate) - It's to use link() to create a
  hard link to a file you want to lock (on the same FS of course).
  (On most NFS implementations, Link() is atomic)

Once you created a hard link (not a symbolic link), with a unique randomly
generated name, call stat() on it and count the number of link (nlink), if there
is only 2 then the file is locked.

If there is more than two you have to unlink() the link you just created and
create a new one with a new unique name (else NFS will use its cache and stat
will return wrong data) then call stat() on the new link and test the number of
links again, repeat this operation until you get the lock.

You have to use usleep() between the link() attempts with a fixed + random
sleep value to avoid dead lock situations (link() and unlink() may be atomic
but not instantaneous)

Also note than when you unlink a file through NFS, if NFS think that the file
is still in use, it will create a .nfs link to this file until it realizes the
file is no longer in use... A wrong timing could generate thousands of those
files and a deadlock situation.  Because of this when a deadlock situation
occurs or if your stat() command returns a very high number of links, you have
to look for .nfs file in the same directory you created your links and unlink
all the .nfs file you find (sometimes NFS take its time to remove them)

- 2 (the simplest) - the second method is to use a lock server and lock daemons
  on each client that will forward lock request to the server... (this is more
dangerous than the first method because the daemons may be killed...)

Here is for reference the function I created to make atomic locks through NFS
(this function is in production since at least 4 years now), it's just for
reference because it uses many external functions to do its job but you can see
the principle:

http://pastey.net/85793
2008-04-14 20:59:59
http://php5.kiev.ua/manual/ru/function.flock.html
Here's a handy class to allow retrying a write with flock a set number of times. If it can't flock, it will sleep for a brief random interval and try again. If you have a lot of concurrent writes going on, you can use it to avoid data corruption.

<?php
class SafeWriter
{
   
// suggested mode 'a' for writing to the end of the file
   
public static function writeData($path$mode$data)
    {
       
$fp fopen($path$mode);
       
$retries 0;
       
$max_retries 100;

        if (!
$fp) {
           
// failure
           
return false;
        }

       
// keep trying to get a lock as long as possible
       
do {
            if (
$retries 0) {
               
usleep(rand(110000));
            }
           
$retries += 1;
        } while (!
flock($fpLOCK_EX) and $retries <= $max_retries);

       
// couldn't get the lock, give up
       
if ($retries == $max_retries) {
           
// failure
           
return false;
        }

       
// got the lock, write the data
       
fwrite($fp"$data\n");
       
// release the lock
       
flock($fpLOCK_UN);
       
fclose($fp);
       
// success
       
return true;
    }
}
?>
2008-07-31 16:36:26
http://php5.kiev.ua/manual/ru/function.flock.html
When writing to a file, you should avoid using w+ because it would erase the contents of the file before locking

If you need to write the complete file again you could use the following instead:

<?php
$fp 
fopen('yourfile.txt''a') ;

if (
flock($fpLOCK_EX)) {
   
ftruncate($fp0) ; // <-- this will erase the contents such as 'w+'
   
   
fputs($fp'test string') ;
   
   
flock($fpLOCK_UN) ;
}

fclose($fp) ;
?>

Best,
Fernando Gabrieli
2009-02-12 13:06:39
http://php5.kiev.ua/manual/ru/function.flock.html
I use exclusive writing to replace standard flock():

<?php
// get/set lock file name
function m_lock_file$format null ) {
    static 
$file_format './%s.lock';
   
    if (
$format !== null) {
       
$file_format $format;
    }
   
    return 
$file_format;
}

// acquire/check/release lock
function m_lock$lockId$acquire null ) {
    static 
$handlers = array();
   
    if (
is_bool($acquire)) {
       
$file sprintf(m_lock_file(), md5($lockId), $lockId);
    }
   
    if (
$acquire === false) {
        if (isset(
$handlers[$lockId])) {
            @
fclose($handlers[$lockId]);
            @
unlink($file);
            unset(
$handlers[$lockId]);
        } else {
           
trigger_error("Lock '$lockId' is already unlocked"E_USER_WARNING);
        }
    }
   
    if (
$acquire === true) {
        if (!isset(
$handlers[$lockId])) {
           
$handler false;
           
$count 100;
            do {
                if (!
file_exists($file) || @unlink($file)) {
                   
$handler = @fopen($file"x");
                }
                if (
false === $handler) {
                   
usleep(10000);
                } else {
                   
$handlers[$lockId] = $handler;
                }
            } while (
false === $handler && $count-- > 0);
        } else {
           
trigger_error("Lock '$lockId' is already locked"E_USER_WARNING);
        }
    }
   
    return isset(
$handlers[$lockId]);
}
?>

Usage sample:

<?php
$lockId 
"qq";

m_lock($lockIdtrue);
if (
m_lock($lockId)) {
    echo 
"locked";

   
// here you can perform any thread-safe operations
   
usleep(300 1000);

   
m_lock($lockIdfalse);
} else {
    echo 
"not locked";
}

?>
2009-08-06 07:31:10
http://php5.kiev.ua/manual/ru/function.flock.html
flock on Solaris is slightly strange: it will fail if you try to get an exclusive lock on a file not opened for writing. That is, for reading files, you MUST use a shared lock. From the Solaris man page for flock:

"Read permission is required on a file to obtain a shared lock, and write  permission is required to obtain an exclusive lock."

In contrast, this is from the Linux man page for flock:

"The mode used to open the file doesn’t matter to flock."

So, beware...
2009-09-08 03:49:12
http://php5.kiev.ua/manual/ru/function.flock.html
Actually, there is no use of the while loop with the usleep. My testing has revealed the following:

<?php
//some code here
flock($file_handleLOCK_EX// <- Your code will pause here untill you get the lock for indefinite amount of time or till your script times out
//some code here
?>

This will actually check for the lock without pausing and then it will sleep:

<?php
//code here
while (!flock($file_handleLOCK_EX LOCK_NB)) {
 
//Lock not acquired, try again in:
 
usleep(round(rand(0100)*1000)) //0-100 miliseconds
}
//lock acquired
//rest of the code
?>

The problem is, if you have a busy site and a lots of locking, the while loop may not acquire the lock for some time. Locking without LOCK_NB is much more persistent and it will wait for the lock for as long as it takes. It is almose guaranteed that the file will be locked, unless the script times out or something.

Consider these two scripts: 1st one is ran, and the second one is ran 5 seconds after the first.

<?php
//1st script
$file_handle fopen('file.test''r+');
flock($file_handleLOCK_EX); //lock the file
sleep(10); //sleep 10 seconds
fclose($file_handle); //close and unlock the file
?>

<?php
//2nd script
$file_handle fopen('file.test''r+');
flock($file_handleLOCK_EX); //lock the file
fclose($file_handle); //close and unlock the file
?>

If you run 1st and then the 2nd script,the 2nd script will wait untill the 1st has finished. As soon as the first script finishes, the second one will acquire the lock and finish the execution. If you use flock($file_handle, LOCK_EX | LOCK_NB) in the 2nd script while the 1st script is running, it would finish execution immediately and you would not get the lock.
2009-12-21 15:47:08
http://php5.kiev.ua/manual/ru/function.flock.html
Because:
1) flock() is not safe if multiple php sessions are simultaneously locking.
2) fopen( , 'a') is not safe if multiple php sessions are simultaneously appending.
3) usleep and sleep are known for having problems.

I wrote the Weblog function, it's purpose is to append a line to logging. This function handles the concurrency as follows:
- Try to create a lockfile named: $directory . date('Ymd') . $logfile . 1 . lock
- If this fails, try to create lockfile named: $directory . date('Ymd') . $logfile . 2 . lock
- etc. After 100 tries return false.

- When the lockfile is acquired the file named: $directory.date('Ymd').$logfile.1 (or .2 or .3 or .25) is opened or created.
- If created the a "extended log file" header is written.
- Write out the line.
- Close the flie and if created set the correct access rights. (I had some problems creating files on a webserver, I did not see them when I opened a FTP session to the webdirectory. The chmod did the trick for me).

- Remove the lockfile.

There is only one drawback, multiple logfiles are created.
e.g. (executed on 15 september 2010)
    Weblog('./' , 'visit', 'Somebody requested the index page');
Could lead to 100 files, depending how many concurrent php sessions are simultaneously trying to append a logline:
./20100915visit.1
./20100915visit.2 
./20100915visit.3
./20100915visit.4
...
./20100915visit.100

This function is donated to the public domain. Maybe you can give me some credit by leaving in the author comment, but it is not required. You may modify this as you wish.
(This function was inspired by the function m_lock_file presented by Kuzma dot Deretuke at gmail dot com)

<?php
function Weblog($directory$logfile$message)
{
   
// Created 15 september 2010: Mirco Babin
   
$curtime time();
   
$logfile date('Ymd',$curtime) . $logfile;

    if (!isset(
$directory) || $directory === false)
       
$directory './';
    if (
substr($directory,-1) !== '/')
       
$directory $directory '/';
       
   
$count 1;
    while(
1)
    {
       
$logfilename $directory $logfile '.' $count;
       
       
$lockfile $logfilename '.lock';
       
$lockhandle false;
        if (!
file_exists($lockfile) || @unlink($lockfile)) 
           
$lockhandle = @fopen($lockfile'xb');
        if (
$lockhandle !== false) break;

       
$count++;
        if (
$count 100) return false;
    }
   
    if (
file_exists($logfilename))
        {
           
$created   false;
           
$loghandle = @fopen($logfilename'ab');
        }
    else
        {
           
$loghandle = @fopen($logfilename'xb');
            if (
$loghandle !== false)
                {
                   
$created true;
                   
                   
$str '#version: 1.0' "\r\n" .
                           
'#Fields: date time c-ip x-msg' "\r\n";
                   
fwrite($loghandle,$str);
                }
            }
   
    if (
$loghandle !== false)
        {
           
$str date('Y-m-d',$curtime) . "\t" 
                   
date('H:i:s'$curtime) .  "\t" .
                   (isset(
$_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : '-') . "\t" .
                   
'"' str_replace('"''""'$message) . '"' "\r\n";
           
fwrite($loghandle,$str);
           
           
fclose($loghandle);
           
            if (
$createdchmod($logfilename,0644); // Read and write for owner, read for everybody else
           
           
$result true;
        }
    else
        {
           
$result false;
        }
   
   
fclose($lockhandle);
    @
unlink($lockfile);

    return 
$result;
}
?>
2010-09-15 13:10:49
http://php5.kiev.ua/manual/ru/function.flock.html
Regarding the change in PHP 5.3.2 with locked files:

Without having studied the PHP source code in detail, the situation appears to be as follows when the PHP function fclose() is called:

Before 5.3.2 PHP would check if the file was locked, then release the lock, and then close the file.

From 5.3.2 PHP just closes the file.

But note, that the operating system releases the lock automatically when the file is closed. Therefore a call to fclose() STILL releases the lock (this is tested with PHP 5.3.2, Linux, x64).
2010-11-11 10:31:39
http://php5.kiev.ua/manual/ru/function.flock.html
I've been having trouble getting Flock to work when I read a file, delete it, and then output slightly changed information back to the same location.  When deleting with Unlink, there's a very brief period of time where no file exists.  But, if you do an fopen using the "w" mode, it keeps the file in existence, but deletes all of its data when you go to write to it.  That way, the file never actually disappears, and another script accessing the same file with flock won't get a "file doesn't exist" error.
2010-12-03 09:53:52
http://php5.kiev.ua/manual/ru/function.flock.html
Автор:
LOCK_NB seems to be checked and works fine in Windows, too, in PHP 5.3.3.

For instance, try concurrently running two instances of the following script (via the CLI). The second prints "Didn't quite get the lock..." as expected, whereas w/o the LOCK_NB flag, it just hangs.

<?php
$x 
fopen("flocktest.txt""w");
if (
flock($xLOCK_EX|LOCK_NB)) {
    print 
"No problems, I got the lock, now I'm going to sit on it.";
    while (
true)
       
sleep(5);
} else {
    print 
"Didn't quite get the lock. Quitting now. Good night.";
}
fclose($x);
?>
2011-01-05 19:13:04
http://php5.kiev.ua/manual/ru/function.flock.html
I just spend a long time to understand why write function returns me "0", on a basic file opening and then writing.

I discovered that if you use LOCK_SH and then you write something, that will not work :

<?php
$fp 
fopen('file.txt''a');

flock($fp,LOCK_SH);

$written fputs($fp'data');

var_dump($written); // 0 and file is not changed

fclose($fp);
?>
2011-09-22 11:44:46
http://php5.kiev.ua/manual/ru/function.flock.html
Notice: On NFS with NFS locking daemon you cannot open file for reading and than lock exklusively:

$rFopened  = fopen($sFile,'r');
$bResult   = flock($rFopened, LOCK_EX);

var_dump($bResult); // returns FALSE

Mixed fopen modes (a+, w+ ...) works with LOCK_EX fine.
2012-03-15 17:15:45
http://php5.kiev.ua/manual/ru/function.flock.html
I just spent some time (again) to understand why a reading with file_get_contents() and file was returning me an empty string "" or array() whereas the file was existing and the contents not empty.

In fact, i was locking file when writing it (file_put_contents third arg) but not testing if file was locked when reading it (and the file was accessed a lot).

So, please pay attention that file_get_contents(), file() and maybe others php files functions are going to return empty data like if the contents of the file was an empty string.

To avoid this problem, you have to set a LOCK_SH on your file before reading it (and then waiting if locked).

Something like this :

<?php
public static function getContents($path$waitIfLocked true) {
    if(!
file_exists($path)) {
        throw new 
Exception('File "'.$path.'" does not exists');
    }
    else {
       
$fo fopen($path'r');
       
$locked flock($foLOCK_SH$waitIfLocked);
       
        if(!
$locked) {
            return 
false;
        }
        else {
           
$cts file_get_contents($path);
           
           
flock($foLOCK_UN);
           
fclose($fo);
           
            return 
$cts;
        }
    }
}
?>

Code to test by yourself :

abc.txt :
someText

file.php :
<?php
$fo 
fopen('abc.txt''r+');

flock($foLOCK_EX);
sleep(10);
flock($foLOCK_UN);
?>

file2.php : 
<?php
var_dump
(file_get_contents('abc.txt'));
var_dump(file('abc.txt'));
?>

Then launch file.php and switch to file2.php during the 10 seconds and see the difference before/after
2012-06-28 19:30:59
http://php5.kiev.ua/manual/ru/function.flock.html
You cannot combine gzopen with flock; so:

<?php
$f 
gzopen($file,'w');
$o flock($fLOCK_EX);
var_dump($o);
flush();
?>

Gives:

boolean false
2013-02-20 17:14:02
http://php5.kiev.ua/manual/ru/function.flock.html
you can wrap a lock as an object to make it a scope-based lock. when the lock object is no longer referenced, like when it's unset or the owner returns, the destructor will call unlock.

this way you can just create a lock object and forget about it.

<?php
class lock {

    private 
$handle;

    public static function 
read $handle ) {
       
$lock = new static();
       
$lock->handle $handle;
        return 
flock($handle,LOCK_SH) ? $lock false;
    }

    public static function 
write $handle ) {
       
$lock = new static();
       
$lock->handle $handle;
        return 
flock($handle,LOCK_EX) ? $lock false;
    }

    public function 
__destruct ( ) {
       
flock($this->handle,LOCK_UN);
    }

}
?>
2013-04-19 03:13:42
http://php5.kiev.ua/manual/ru/function.flock.html
Use rename or unlink on handled file breaked LOCK_EX flock on handle (Linux only).

Example:

$handle = fopen($lockFile, 'c');
var_dump(flock($handle, LOCK_EX | LOCK_NB)); // false because flock use other php process
rename($lockFile, $lockFile.'.old'); // or unlink
var_dump(flock($handle, LOCK_EX | LOCK_NB)); // always true (!!!)
2014-01-04 22:36:37
http://php5.kiev.ua/manual/ru/function.flock.html
if you are used to reply with qualified error messages by using "track_errors = 1" and $php_errormsg,  flock() will nark you, if you use LOCK_NB .

If flock() fails due to LOCK_NB $php_errormsg will not be created and filled with an error message like 'could not lock file, file already locked'.

You can use some little workaround which does also on WIN:

#---------------------------------
GLOBAL $MYERRORMSG;

function some_file_operations($filename)
{
    GLOBAL $MYERRORMSG;

    # ...
    # ...

    if (! @flock($fh, LOCK_SH | LOCK_NB, $wb))
       {
        if (!isset($php_errormsg)) $php_errormsg = 'could not lock file, file already locked';
        $MYERRORMSG = $php_errormsg;
        return false;
    }   
}
#--------------------------------

In case of fail $MYERRORMSG now will hold a qualified error message
2014-04-28 21:46:49
http://php5.kiev.ua/manual/ru/function.flock.html
"Assigning another value to handle argument in subsequent code will release the lock."
Note: this is also true for losing the handle's context completely (like returning from a function, in which the handle was a local variable).

<?php
touch
("testfile");

function 
mylock() {
 
$F1 fopen("testfile","r");
  if (
flock($F1,LOCK_EX|LOCK_NB)) echo "First lock OK\n"; else echo "First lock FAIL\n";
 
$F2 fopen("testfile","r");
  if (
flock($F2,LOCK_EX|LOCK_NB)) echo "Second lock OK\n"; else echo "Second lock FAIL\n";
}

mylock();
echo 
"Function returned.\n";
mylock();

unlink("testfile");
?>

Prints out:

First lock OK
Second lock FAIL
Function returned.
First lock OK
Second lock FAIL

This will lock the testfile, then attempt to lock it again with a new file handle (obviously failing). Trying this again, though, results in proper locking again (and then failing again), because when exiting the function both handles are lost and automatically unlocked.
2014-08-15 17:01:32
http://php5.kiev.ua/manual/ru/function.flock.html
Note that Example #1 contains a bug: ftruncate() does *not* re-set the file pointer to the beginning of the file. You need to execute a call to rewind() afterward. I realize that the ftruncate page does mention this, but if anybody copies the example above (as I did), their program will not work correctly unless they fix this.
2015-02-27 07:32:16
http://php5.kiev.ua/manual/ru/function.flock.html
Simple Helper for lock files creation

<?php

class FileLocker {
    protected static 
$loc_files = array();

    public static function 
lockFile($file_name$wait false) {
       
$loc_file fopen($file_name'c');
        if ( !
$loc_file ) {
            throw new 
Exception('Can\'t create lock file!');
        }
        if ( 
$wait ) {
           
$lock flock($loc_fileLOCK_EX);
        } else {
           
$lock flock($loc_fileLOCK_EX LOCK_NB);
        }
        if ( 
$lock ) {
           
self::$loc_files[$file_name] = $loc_file;
           
fprintf($loc_file"%s\n"getmypid());
            return 
$loc_file;
        } else if ( 
$wait ) {
            throw new 
Exception('Can\'t lock file!');
        } else {
            return 
false;
        }
    }

    public static function 
unlockFile($file_name) {
       
fclose(self::$loc_files[$file_name]);
        @
unlink($file_name);
        unset(
self::$loc_files[$file_name]);
    }



if ( !
FileLocker::lockFile('/tmp/1.lock') ) {
    echo 
"Can't lock file\n";
    die();
}
sleep(10);
FileLocker::unlockFile('/tmp/1.lock');
echo 
"All Ok\n";
2015-04-24 09:34:07
http://php5.kiev.ua/manual/ru/function.flock.html
If you are interested in using file locking as indicator that your console app is running and you don't want to start it again:

 if (!flock($fp, LOCK_EX | LOCK_NB, $wouldblock)) {
                if ($wouldblock) {
                    //Another process holds the lock!
               
                } else {
                    //Couldn't lock for another reason, e.g. no such file
             
                }
            } else {
                //Lock obtained

                startJob();
            }
Please note that this is platform independent solution, but you have restrictions in PHP version (5.5.22 on Windows).
Also, some old file systems are not supported.
2016-03-01 16:49:41
http://php5.kiev.ua/manual/ru/function.flock.html
And here's the timeout template for UNIX:

<?php
pcntl_signal
(SIGALRM, function() {});
pcntl_alarm(3);
try {
    if (!
flock($handleLOCK_EX)) {
        throw new 
Exception("Timeout");
    }
finally {
   
pcntl_alarm(0);
   
pcntl_signal_dispatch();
   
pcntl_signal(SIGALRMSIG_DFL);
}
?>
2016-12-04 21:20:39
http://php5.kiev.ua/manual/ru/function.flock.html
Автор:
When a file is closed the lock will be released by the system anyway, even if PHP doesn't do it explicitly anymore since 5.3.2 (the documentation is very confusing about this).

However, I had a situation on an apache/PHP server where an out-of-memory error in PHP caused file handles to not be closed and therefore the locks where kept even thought PHP execution had ended and the process had returned to apache to serve other requests. The lock was kept alive until apache recycled those processes.

This lack of proper clean up basically makes flock() completely unreliable.
2017-03-27 09:14:10
http://php5.kiev.ua/manual/ru/function.flock.html
Relying on flock for synchronise things is risky, consider using extensions like SYNC or pthreads instead.
2017-06-07 04:40:17
http://php5.kiev.ua/manual/ru/function.flock.html

    Поддержать сайт на родительском проекте КГБ