PHP 7.4.9 Released!

msg_receive

(PHP 4 >= 4.3.0, PHP 5, PHP 7)

msg_receiveEine Nachricht aus einer Message Queue auslesen

Beschreibung

msg_receive ( resource $queue , int $desiredmsgtype , int &$msgtype , int $maxsize , mixed &$message [, bool $unserialize = TRUE [, int $flags = 0 [, int &$errorcode ]]] ) : bool

msg_receive() liest die erste Nachricht der Message Queue gegeben durch queue vom Typ desiredmsgtype aus.

Parameter-Liste

queue

Message Queue Ressourcen-Handle

desiredmsgtype

Wenn desiredmsgtype gleich 0 ist, wird die erste Nachricht aus der Queue zurückgegeben. Wenn desiredmsgtype größer als 0 ist, wird die erste Nachricht genau diesen Typs zurückgegeben. Wenn desiredmsgtype kleiner als 0 ist, wird die erste Nachricht kleiner oder gleich dem absoluten Wert von desiredmsgtype zurückgegeben. Wenn keine passende Nachricht existiert, blockiert diese Funktion solange, bis eine passende Nachricht verfügbar ist. Durch das Setzen des Flags MSG_IPC_NOWAIT im flags Parameter kann das blockierende Verhalten verhindert werden.

msgtype

In diesem Parameter wird der Typ der empfangenen Nachricht gespeichert.

maxsize

Die maximale Größe der zu akzeptierenden Nachricht wird durch maxsize angegeben; Wenn die Nachricht in der Message Queue größer ist als dieser Wert schlägt die Funktion fehl (es sei denn, es wird das entsprechende Flag im flags Parameter gesetzt).

message

Die empfangene Nachricht wird in message gespeichert, es sei denn es tritt ein Fehler beim Empfang auf.

unserialize

Wenn dieser Wert auf TRUE gesetzt wird, wird die Nachricht behandelt, als wäre sie mit demselben Mechanismus serialisiert worden, wie das Session Modul. Die Nachricht wird deserialisiert und zurückgegeben. Dies erlaubt einen einfachen Empfang von Array und komplexen Objektstrukturen von anderen PHP Skripten. Wenn Sie den WDDX Serializer verwenden, erlaubt es den Empfang von einer WDDX kompatiblen Quelle.

Wenn unserialize FALSE ist, wird die Nachricht als binärsicherer String zurückgegeben.

flags

Der optionale flags erlaubt die Weitergabe von Flags an den low-level System Call zu msgrcv. Der Standardwert liegt bei 0, aber es können einer oder mehrere der folgenden Werte übergeben werden (durch binäres oder vereint).

Flag Werte für msg_receive
MSG_IPC_NOWAIT Wenn kein Wert des übergebenen desiredmsgtype in der Queue vorhanden ist, gibt die Funktion sofort zurück statt zu warten. Die Funktion schlägt fehl und gibt den Integer Wert entsprechend zu MSG_ENOMSG zurück.
MSG_EXCEPT Dieses Flag in Kombination mit einem desiredmsgtype größer als 0 sorgt dafür, dass die Funktion die erste Nachricht zurück gbit, die nicht gleich desiredmsgtype ist.
MSG_NOERROR Wenn die Nachricht länger als maxsize ist, wird durch Setzen diese Flags die Nachricht auf maxsize gekürzt, und die Funktion signalisiert keinen Fehler.

errorcode

Wenn die Funktion fehlschlägt, wird der optionale errorcode auf den Wert der System errno Variable gesetzt.

Rückgabewerte

Gibt bei Erfolg TRUE zurück. Im Fehlerfall wird FALSE zurückgegeben.

Bei erfolgreicher Ausführung wird die Message Queue Datenstruktur folgendermaßen aktualisiert: msg_lrpid wird auf die Process-ID des aufrufenden Prozesses gesetzt, msg_qnum wird um 1 dekrementiert, und msg_rtime wird auf die aktuelle Zeit gesetzt.

Siehe auch

add a note add a note

User Contributed Notes 6 notes

up
4
marbledore at mail dot ru
9 years ago
It looks like msg_receive() allocates a memory with size $maxsize, and only then tries to receive a message from queue into allocated memory. Because my script dies with $maxsize = 1 Gib, but works with $maxsize = 10 Kib.
up
1
marvel at post dot cz
12 years ago
Consider this e.g. Linux situation:

<?php
//file send.php
$ip = msg_get_queue(12340);
msg_send($ip,8,"abcd",false,false,$err);
//-----------------------------------------------------
<?php
//file receive.php
$ip = msg_get_queue(12340);

msg_receive($ip,0,$msgtype,4,$data,false,null,$err);
echo
"msgtype {$msgtype} data {$data}\n";

msg_receive($ip,0,$msgtype,4,$data,false,null,$err);
echo
"msgtype {$msgtype} data {$data}\n";
?>

Now run:
in terminal #1   php5 receive.php
in terminal #2   php5 receive.php
in terminal #3   php5 send.php

Showing messages from queue will flip-flop. It means you run once send.php, the message will be shown in terminal #1. Second run it will be in t#2, third #1 and so on.
up
0
soger
1 year ago
It seems that a maxsize of 2Mb is some sort of a threshold for php, above that msg_receive() starts to use a lot of CPU (with a sender that is pushing messages non-stop receiving 10000 messages jumps up from 0.01 sec to 1.5 sec on my computer) so try to stay below that thresholod if you can.
up
0
shepik at yandex dot ru
11 years ago
The behaviour of msg_recieve function depends on value of $desiredmsgtype:
If zero: the first message with any $msgtype will be recieved.
Positive: the first message with $msgtype = desiredmsgtype
Negative: the first message with $msgtype <= abs ($desiredmsgtype)
(where "$msgtype" means msgtype the message was sent with)
up
0
webmaster at toolshed51 dot com
17 years ago
This is meant to be run as your apache user in a terminal, call script in note of msg_send and they will communicate.

#! /usr/bin/env php
<?php
    $MSGKEY
= 519051; // Message

   
$msg_id = msg_get_queue ($MSGKEY, 0600);

    while (
1) {
        if (
msg_receive ($msg_id, 1, $msg_type, 16384, $msg, true, 0, $msg_error)) {
            if (
$msg == 'Quit') break;
            echo
"$msg\n";
        } else {
            echo
"Received $msg_error fetching message\n";
            break;
        }
    }

   
msg_remove_queue ($msg_id);
?>
up
-1
eimers at mehrkanal dot com
12 years ago
<?php error_reporting(E_ALL);
/**
* Example for sending and receiving Messages via the System V Message Queue
*
* To try this script run it synchron/asynchron twice times. One time with ?typ=send and one time with ?typ=receive
*
* @author          Thomas Eimers - Mehrkanal GmbH
*
* This document is distributed in the hope that it will be useful, but without any warranty;
* without even the implied warranty of merchantability or fitness for a particular purpose.
*/

header('Content-Type: text/plain; charset=ISO-8859-1');
echo
"Start...\n";

// Create System V Message Queue. Integer value is the number of the Queue
$queue = msg_get_queue(100379);

// Sendoptions
$message='nachricht';     // Transfering Data
$serialize_needed=false// Must the transfer data be serialized ?
$block_send=false;        // Block if Message could not be send (Queue full...) (true/false)
$msgtype_send=1;          // Any Integer above 0. It signeds every Message. So you could handle multible message
                          // type in one Queue.

// Receiveoptions
$msgtype_receive=1;       // Whiche type of Message we want to receive ? (Here, the type is the same as the type we send,
                          // but if you set this to 0 you receive the next Message in the Queue with any type.
$maxsize=100;             // How long is the maximal data you like to receive.
$option_receive=MSG_IPC_NOWAIT; // If there are no messages of the wanted type in the Queue continue without wating.
                          // If is set to NULL wait for a Message.

// Send or receive 20 Messages
for ($i=0;$i<20;$i++) {
 
sleep(1);
 
// This one sends
 
if ($_GET['typ']=='send') {
    if(
msg_send($queue,$msgtype_send, $message,$serialize_needed, $block_send,$err)===true) {
      echo
"Message sendet.\n";
    } else {
     
var_dump($err);
    }
 
// This one received
 
} else {
   
$queue_status=msg_stat_queue($queue);
    echo
'Messages in the queue: '.$queue_status['msg_qnum']."\n";

   
// WARNUNG: nur weil vor einer Zeile Code noch Nachrichten in der Queue waren, muss das jetzt nciht mehr der Fall sein!
   
if ($queue_status['msg_qnum']>0) {
      if (
msg_receive($queue,$msgtype_receive ,$msgtype_erhalten,$maxsize,$daten,$serialize_needed, $option_receive, $err)===true) {
              echo
"Received data".$daten."\n";
      } else {
             
var_dump($err);
      }
    }
  }
}

?>
To Top