CascadiaPHP 2024

Fonctions Sémaphore


  • ftok — Convertit un chemin et un identifiant de projet en une clé System V IPC
  • msg_get_queue — Crée ou s'attache à une file de messages
  • msg_queue_exists — Vérifie si une file de messages existe
  • msg_receive — Reçoit un message depuis une file de messages
  • msg_remove_queue — Détruit une file de messages
  • msg_send — Envoie un message dans une file
  • msg_set_queue — Modifie des informations dans la file de messages
  • msg_stat_queue — Retourne des informations sur la file de messages
  • sem_acquire — Réserve un sémaphore
  • sem_get — Retourne un identifiant de sémaphore
  • sem_release — Libère un sémaphore
  • sem_remove — Détruit un sémaphore
  • shm_attach — Crée ou ouvre un segment de mémoire partagée
  • shm_detach — Libère un segment de mémoire partagée
  • shm_get_var — Lit une variable dans la mémoire partagée
  • shm_has_var — Vérifie si une variable existe en mémoire partagée
  • shm_put_var — Insère ou modifie une variable de la mémoire partagée
  • shm_remove_var — Efface une variable de la mémoire partagée
  • shm_remove — Supprime un segment de mémoire partagée sous Unix
add a note

User Contributed Notes 6 notes

elran70 at hotmail dot com
22 years ago
Samlpe code for using most of the functions here:

$MEMSIZE = 512;// size of shared memory to allocate
$SEMKEY = 1; // Semaphore key
$SHMKEY = 2; // Shared memory key

echo "Start.\n";
// Get semaphore
$sem_id = sem_get($SEMKEY, 1);
if ($sem_id === false)
echo "Fail to get semaphore";
echo "Got semaphore $sem_id.\n";

// Accuire semaphore
if (! sem_acquire($sem_id))
echo "Fail to aquire semaphore $sem_id.\n";
echo "Success aquire semaphore $sem_id.\n";

$shm_id = shm_attach($SHMKEY, $MEMSIZE);
if ($shm_id === false)
echo "Fail to attach shared memory.\n";
echo "Success to attach shared memory : $shm_id.\n";

// Write variable 1
if (!shm_put_var($shm_id, 1, "Variable 1"))
echo "Fail to put var 1 on shared memory $shm_id.\n";
shm_remove ($shm_id);
echo "Write var1 to shared memory.\n";

// Write variable 2
if (!shm_put_var($shm_id, 2, "Variable 2"))
echo "Fail to put var 2 on shared memory $shm_id.\n";
shm_remove ($shm_id);
echo "Write var2 to shared memory.\n";

// Read variable 1
$var1 = shm_get_var ($shm_id, 1);
if ($var1 === false)
echo "Fail to retrive Var 1 from Shared memory $shm_id, return value=$var1.\n";
echo "Read var1=$var1.\n";

// Read variable 1
$var2 = shm_get_var ($shm_id, 2);
if ($var1 === false)
echo "Fail to retrive Var 2 from Shared memory $shm_id, return value=$var2.\n";
echo "Read var2=$var2.\n";

// Release semaphore
if (!sem_release($sem_id))
echo "Fail to release $sem_id semaphore.\n";
echo "Semaphore $sem_id released.\n";

// remove shared memory segmant from SysV
if (shm_remove ($shm_id))
echo "Shared memory successfully removed from SysV.\n";
echo "Fail to remove $shm_id shared memory from SysV.\n";

// Remove semaphore
if (sem_remove($sem_id))
echo "semaphore removed successfully from SysV.\n";
echo "Fail to remove $sem_id semaphore from SysV.\n";
echo "End.\n";
hekkwan at gmail dot com
17 years ago
I have been trying to get a php console script and a C application to use a common semaphore for a while. I just got it working, so I thought Id paste the code here incase anyone needs to do this, however, this is not the place for long code examples

I used c code from the php implementation to set up the semaphore set and then mimic the way the php interpreter implements a mutext type locking scheme, using a common semop call.

One has to do the process in the same way as its done in the php implementation, otherwise you run the risk of the php interpreter resetting the semaphore set for you.

The basic idea is.
1) sem_get - use a three semaphore set
1.1) increment the first sem
1.2) check the usage count (sem 3), if only one, set the max_attach using sem 2 for mutex behaviour to sem 3
2) decrement sem 1
3) for locking / unlocking use the first semaphore, but always call the above from your c-code.

If you want a copy of my code, email me and I'll happily send it to you !
chrissavery at removeme dot gmail dot com
18 years ago
I was confused by two things that caused strange behaviour in my use of semaphores with php scripts running under apache.

Often enough page requests will end up being filled by the same process as other simultaneous requests. So semaphores will block when you may not have expected.

Also note that sem_remove() will remove it for all processes, not just the calling one. So you have to be sure that the last process running removes the semaphore and none before. I thought there was some failures occurring when my child processes were dropping out with errors.

So you can't just use get, acquire, release, remove in one script that will be hit by a web user. (1) They may end up in the same process and will wait on the other, and (2) the first one to finish will destroy the semaphore for others.

I left out the remove call, and it works ok, but I still wonder if the semaphore is removed by php when the last script that did a get finishes? Also creating a child process to do the work using proc_open works to ensure seperate processes but to be careful you would want to limit the number somehow as well.
php at stolt dot de
23 years ago
The integer keys for sem_get() and shm_attach() have to be systemwide unique. There is no method to ensure that no other process on the system will use your specific key (security! and possible malfunction). Also shared memory is very seldom used there are possibilities for conflicts! To see the used id's you can use the program 'ipcs' (at least under SuseLinux;) ). Thanks Christian C.
hcuevas at galenicom dot com
20 years ago
Don't use semaphores to serialize access to an undefined number of resources. There is no way (yet) to know before locking if a semaphore is already locked, thus not being able to fully release the semaphore and occupying a semaphore resource for an undefined time.

A possible solution is to build a shared mem pool and store there the current number of locks for a semaphore id.

Horaci Cuevas
Roman Laptev <tmp at laptev dot org>
21 years ago
If you going to work with semaphore, which was created by some external program, you can try the following code for this program (C example):

#define SVSEM_MODE (SEM_R | SEM_A | SEM_R>>3 | SEM_R>>6) /* 0644 */

int semid, semflag = SVSEM_MODE | IPC_CREAT | IPC_EXCL;
struct sembuf semptr;
union semun semopts;
if( (semid = semget(sempath, PHP_SEM_NEED_NUMBER, semflag)) >= 0 ) {
semopts.val = 1; /* initial value for sem */
if( semctl( semid, 0, SETVAL, semopts) < 0 ) {/*error*/}
if( semctl( semid, 1, SETVAL, semopts) < 0 ) {/*error*/}
/* PHP wanna zero for its own semget at third sem.
* look at ./PHP_SOURCE_PATH/ext/sysvsem/sysvsem.c
semopts.val = 0;
if( semctl( semid, 2, SETVAL, semopts) < 0 ) {/*error*/}
else if(errno == EEXIST) { /* connect only */
if( (semid = semget(sempath, PHP_SEM_NEED_NUMBER, SVSEM_MODE | IPC_CREAT)) < 0 ) {/*error*/}
else {/*error*/}

/* If you want acquire the sem */
semptr.sem_num = 0;
semptr.sem_op = -1; /* lock it */
semptr.sem_flg = SEM_UNDO;
while( semop(semid, &semptr, 1) < 0 ) {/*error*/}

To Top