public function __construct()
 {
     $this->ipc_fn = tempnam(sys_get_temp_dir(), 'csp.' . uniqid('chn', true));
     $this->key = ftok($this->ipc_fn, 'A');
     $this->ipc = msg_get_queue($this->key, 0666);
     msg_set_queue($this->ipc, $cfg = ['msg_qbytes' => 1 * PHP_INT_LENGTH]);
 }

 /**
  * Init Tunnel.
  */
 public function __construct()
 {
     $this->parentPID = getmypid();
     $this->bridge = $this->createBridge();
     $this->queue = msg_get_queue(ftok(__FILE__, 'k'));
     pcntl_signal(POLL_MSG, [$this, 'read']);
 }

 public function shutdown()
 {
     $this->queue = msg_get_queue(ftok($this->file, 'R'), 0777);
     for ($i = 0; $i < $this->numThreads * 2; $i++) {
         msg_send($this->queue, 100 + $i, 'shutdown');
     }
 }

 public function actionDequeue($qId, $data)
 {
     $q = msg_get_queue($qId);
     $r = msg_receive($q, 1, $msgType, 10000, $msg);
     echo "Result: " . $r . "<br/>";
     echo " Got msg: " . $msg;
 }

 public static function getInstance()
 {
     if (!self::$_queue) {
         self::$_queue = msg_get_queue(self::LC_MSG_KEY);
     }
     return self::$_queue;
 }

 public function __construct($id, $info)
 {
     $this->id = $id;
     $this->info = $info;
     $this->msgSemKey = sem_get(9876543210);
     $this->queKey = msg_get_queue(123456788);
 }

 public function __construct(Config $config)
 {
     $this->ownerPid = $config->get('ownerPid');
     $this->ipcKey = new IpcKey($this->ownerPid, str_replace('\\', '_', get_class($this)));
     $this->id = msg_get_queue($this->ipcKey->generate());
     $this->stat = msg_stat_queue($this->id);
 }

 private function getQueue()
 {
     if ($this->_queue === null) {
         $this->_queue = msg_get_queue($this->getKey(), $this->permissions);
     }
     return $this->_queue;
 }

 protected function initQueue()
 {
     if (null !== $this->msgHandle) {
         return;
     }
     $this->msgHandle = msg_get_queue($this->getId());
 }

 public function initialize()
 {
     if ($this->queuePath) {
         return;
     }
     $this->queuePath = KATATMP . 'queue' . DS;
     if (defined('QUEUE_IDENTIFIER')) {
         $this->queueId = QUEUE_IDENTIFIER;
     } else {
         if (defined('CACHE_IDENTIFIER')) {
             $this->queueId = (int) hexdec(md5(CACHE_IDENTIFIER));
         } else {
             $this->queueId = ftok(__FILE__);
         }
     }
     switch ($this->method) {
         case null:
             throw new Exception('You have to setMethod() first');
             break;
         case self::QM_MSGQUEUE:
             $this->queueRes = msg_get_queue($this->queueId, 0666);
             break;
         case self::QM_ZEROMQ:
             break;
         case self::QM_LIBEVENT:
             break;
         case self::QM_FILESOCKET:
             break;
         case self::QM_FILESYS:
             break;
     }
     //switch
 }

 public function setKey($key)
 {
     if ($this->key !== $key) {
         $this->key = $key;
         $this->queue = msg_get_queue($this->key);
     }
 }

 public function __construct($queue_file)
 {
     if (!file_exists($queue_file)) {
         throw new Exception("Could not find mailbox: {$queue_file}");
     }
     $this->queue_id = msg_get_queue(ftok($queue_file, 'r'), 0666);
 }

 /**
  * Create a ParallelChildCollector that will collect
  * issues as normal, but emit them to a message queue
  * for collection by a
  * \Phan\Output\Collector\ParallelParentCollector.
  */
 public function __construct()
 {
     assert(extension_loaded('sysvsem'), 'PHP must be compiled with --enable-sysvsem in order to use -j(>=2).');
     assert(extension_loaded('sysvmsg'), 'PHP must be compiled with --enable-sysvmsg in order to use -j(>=2).');
     // Create a message queue for this process group
     $message_queue_key = posix_getpgid(posix_getpid());
     $this->message_queue_resource = msg_get_queue($message_queue_key);
 }

 protected function getQueue($queueName)
 {
     if (!isset($this->semaphore[$queueName])) {
         $id = crc32($queueName);
         $this->semaphore[$queueName] = msg_get_queue($id);
     }
     return $this->semaphore[$queueName];
 }

 /**
  * init queue
  *
  * @param $ipc_filename
  * @param $msg_type
  * @throws \Exception
  */
 protected function initQueue($ipc_filename, $msg_type)
 {
     $this->key_t = $this->getIpcKey($ipc_filename, $msg_type);
     $this->queue = \msg_get_queue($this->key_t);
     if (!$this->queue) {
         throw new \RuntimeException('msg_get_queue failed');
     }
 }

 /**
  * @param EventDispatcherInterface $dispatcher
  * @param array $customEvents Custom events to proxy to parent process.
  */
 public function __construct(EventDispatcherInterface $dispatcher, array $customEvents = [])
 {
     $this->dispatcher = $dispatcher;
     $class = new \ReflectionClass('\\Unteist\\Event\\EventStorage');
     $this->events = array_unique(array_values($class->getConstants() + $customEvents));
     $this->parentPID = getmypid();
     $this->queue = msg_get_queue(ftok(__FILE__, 'U'));
 }

 /**
  * @param   int     $ownerPid
  * @param   int     $maxProcs
  */
 public function __construct($ownerPid, $maxProcs)
 {
     $this->keyPrefix = uniqid((string) mt_rand(1, 100), true);
     $this->ownerPid = $ownerPid;
     $this->maxProcs = $maxProcs;
     $this->id = msg_get_queue($this->genId());
     $this->initializeQueue();
 }

 /**
  * Get queue
  * 
  * @return resource
  */
 public function getQueue()
 {
     if (!($this->queue = msg_get_queue($this->qid, 0666))) {
         throw new Hush_Message_Exception("Get queue " . $this->name . " failed");
         return false;
     }
     return $this->queue;
 }

 /**
  * 初始化一个队列
  * @param $ipc_filename
  * @param $msg_type
  * @throws Exception
  */
 public function init_queue($ipc_filename, $msg_type)
 {
     $this->key_t = $this->get_ipc_key($ipc_filename, $msg_type);
     $this->queue = \msg_get_queue($this->key_t);
     if (!$this->queue) {
         throw new \Exception('msg_get_queue failed');
     }
 }

 /**
  * @throws \RuntimeException
  */
 protected function init()
 {
     $file = sprintf("%s/%s", sys_get_temp_dir(), base64_encode($this->identifier));
     @touch($file);
     $this->queue = msg_get_queue(ftok($file, 'm'));
     if (!$this->queue) {
         throw new \RuntimeException("Unable to get message queue");
     }
 }