Imposta il tuo tema preferito!
Hai l'occasione di scegliere un tema per questo sito tra quelli che ti proponiamo!
Cos facendo, potrai personalizzare qualunque pagina di questo sito Web.

La procedura totalmente gratuita e non richiede la registrazione o il login al sito.
Grazie ad essa, potrai tranquillamente leggere la pagina Web di questo sito con la tua anteprima preferita!
Ti basta andare nel link che ti riportiamo qui sotto e, visualizzandone le varie anteprime, scegliere un tema!
Tutto semplicemente a portata di... mouse e di click!


Evitare sovrascrittura dei file in PHP
Spesso, in PHP può capitare che vengano fatte più richieste di accesso ad un determinato file pressoché contemporaneamente, generalmente a causa di un elevato numero di utenti connessi in quel determinato momento.
Tuttavia, in alcune condizioni l'uso di funzioni quali file_get_contents() e file_put_contents(), nonché fopen(), fwrite() e simili può portare al troncamento a lunghezza zero di un file se viene letto o scritto contemporaneamente da più script PHP, o dallo stesso script eseguito più volte contemporaneamente.
Per evitare questo incidente, è possibile creare dei semafori.
In sostanza, si tratta di file che segnalano che il file è in fase di lettura\scrittura e che, quindi, al momento non deve essere letto o scritto perchè già in uso.
In particolare, dato che anche nel "semaforo" si potrebbe verificare perdita di dati per lo stesso motivo, e che quindi risulterebbe inaffidabile se l'importante è il suo contenuto, è possibile usare la funzione unlink().
Tale funzione restituisce true solo ed esclusivamente se l'eliminazione del file è riuscita; altrimenti restituisce false.
Pertanto si può fare una cosa del genere:


function LockSemaphore($strSemaphoreFile)
{
$i = 0;
for( $i = 0; $i <= 10000000; ++$i )
{
if( unlink( $strSemaphoreFile ) === true )
{
return true; // Operazione riuscita, restituisce true
}
}
return false; // Operazione fallita, il limite di 10000000 di cicli è scaduto.
}
function UnlockSemaphore($strSemaphoreFile)
{
if( file_put_contents($strSemaphoreFile, "Semaphore File") === false ) // Il contenuto non è importante.
{
return false;
}
else
{
return true;
}
}
function WriteMyFile($strFile, $strData)
{
$bIsSemaphoreLocked = LockSemaphore("semaphore.sph"); // Il nome del semaforo è a libera scelta
if( $bIsSemaphoreLocked === false ) // Impossibile bloccare il semaforo
{
return false; // Server occupato
}
$writingRes = file_put_contents($strFile, $strData);
$bIsSemaphoreUnlocked = UnlockSemaphore("semaphore.sph");
if( $writingRes === false )
{
return false;
}
return $writingRes; // Restituisce il numero di byte scritti
}

$fileWritingResult = WriteMyFile("myfile.txt", "It is my file! Don't touch it!");
if( $fileWritingResult === false )
{
exit("<b>Spiacente</b>, questo server è occupato.<br><br>Riprova più tardi.");
}
exit("<b>Richiesta salvata</b> con successo.");


Cosa succede?
La funzione LockSemaphore() tenta per un massimo di 10 milioni di volte di eliminare con unlink() il file che fa da semaforo, specificato come argomento $strSemaphoreFile.
Se la funzione unlink() fallisce 10 milioni di volte, viene restituito false. Altrimenti il file verrà cancellato e a nessun'altro script PHP in esecuzione contemporaneamente può risultare true. Gli altri dovranno attendere la disponibilità del file.
Quando il semaforo è ormai stato bloccato, si è più o meno certi che nessun'altro script PHP, se usa questo sistema, accederà contemporaneamente al file.
Ora possiamo tranquillamente scrivere sul file o sui file che il semaforo normalmente blocca utilizzando file_put_contents().
Da notare che la funzione WriteMyFile() rilascia il semaforo non appena ha finito di scrivere, ciò diventa particolarmente oneroso in termini di CPU e di altre risorse sul server nel caso in cui bisogna scrivere su più file.
In questo caso, occorrerebbe prima una chiamata a LockSemaphore(), poi se restituisce true si scrive su tutti i file protetti dal semaforo su cui bisogna scrivere, e per finire una chiamata a UnlockSemaphore() ci assicura che il file o i file verrè\verranno letto\i e scritto\i dagli altri script PHP se necessario.
Nel caso LockSemaphore(), restituisca false, non deve essere toccato alcun file di quelli protetti dal semaforo per evitare la sovrascrittura.
Il numero massimo di cicli può essere modificato in modo tale che non causi alcun timeout (normalmente di 30 secondi) durante l'esecuzione.

Se si devono controllare valori forniti in input dall'utente attraverso richieste GET o POST, è consigliabile farlo prima, così come altre eventuali azioni che non richiedono l'uso di file.
È meglio rilasciare quanto prima possibile il blocco perché altrimenti si rischia di creare code ed altri problemi.
Inoltre, in caso di sovraccarico del server, tutti questi tentativi così frequenti e l'uso enorme della CPU possono rallentare lo script PHP che detiene il blocco dei file, e ciò risulterebbe controproducente.
Per questo sarebbe più conveniente mettere una funzione usleep() che mette in pausa l'esecuzione dello script PHP per un determinato numero di microsecondi (un microsecondo è un milionesimo di un secondo, ossia un secondo equivale a un milione di microsecondi).
Un'altra funzione simile è sleep(), che invece sospende l'esecuzione per un numero intero di secondi, quindi il minimo di attesa è di 1 secondo e non ci sono valori intermedi tra i secondi (il parametro è di tipo int).
Altre funzioni simili sono:
Evitare+sovrascrittura+file+PHP
Lasciaci un commento!


---

---



Caratteri disponibili:
0

-----

------
Invia commento
-------
Invio del messaggio in corso... Attendere...

I campi contrassegnati con l'asterisco (
*
) sono obbligatori.
L'e-mail non verrà pubblicata.


Nessun commento!
Lasciane uno tu per primo!