PHP shmop_delete函数代码示例

 /**
  * Writes a message to the shared memory.
  *
  * @param mixed   $message The message to send
  * @param integer $signal  The signal to send afterward
  * @param integer $pause   The number of microseconds to pause after signalling
  */
 public function send($message, $signal = null, $pause = 500)
 {
     $messageArray = array();
     if (($shmId = @shmop_open($this->pid, 'a', 0, 0)) > 0) {
         // Read any existing messages in shared memory
         $readMessage = shmop_read($shmId, 0, shmop_size($shmId));
         $messageArray[] = unserialize($readMessage);
         shmop_delete($shmId);
         shmop_close($shmId);
     }
     // Add the current message to the end of the array, and serialize it
     $messageArray[] = $message;
     $serializedMessage = serialize($messageArray);
     // Write new serialized message to shared memory
     $shmId = shmop_open($this->pid, 'c', 0644, strlen($serializedMessage));
     if (!$shmId) {
         throw new ProcessControlException(sprintf('Not able to create shared memory segment for PID: %s', $this->pid));
     } else {
         if (shmop_write($shmId, $serializedMessage, 0) !== strlen($serializedMessage)) {
             throw new ProcessControlException(sprintf('Not able to write message to shared memory segment for segment ID: %s', $shmId));
         }
     }
     if (false === $signal) {
         return;
     }
     $this->signal($signal ?: $this->signal);
     usleep($pause);
 }

 function MonClose()
 {
     if (!shmop_delete($this->{$shm_id})) {
         debug("No se pudo borrar el segmento de memoria compartida.", "red");
     }
     shmop_close($this->{$shm_id});
 }

 /**
  * Resize memory block
  * @param int $size
  * @return bool
  */
 protected function resize($size)
 {
     if ($size > $this->max_size) {
         return false;
     }
     //should be called AFTER reading memory (to not loose changing of variables)
     if (empty($this->mem)) {
         return false;
     }
     ignore_user_abort(true);
     set_time_limit(180);
     if (is_array($this->mem)) {
         $this->mem[self::map_info][self::map_info_resized] = $this->mem[self::map_info][self::map_info_resized] + 1;
         $this->mem[self::map_info][self::map_info_resizetime] = time();
     }
     shmop_delete($this->shm);
     shmop_close($this->shm);
     $t = serialize($this->mem);
     $memsize = strlen($t);
     if ($memsize > $size) {
         $size = $memsize + 1000;
     }
     $this->shm = shmop_open($this->shmkey, "n", 0777, $size);
     if (!$this->shm) {
         return false;
     }
     //mmm... oops.
     unset($this->mem);
     $w = shmop_write($this->shm, str_pad($t, shmop_size($this->shm), ' ', STR_PAD_RIGHT), 0);
     if (!$w) {
         return false;
     }
     return true;
 }

 /**
  * @param $key
  * @param int $mode
  * @param int $size
  * @return mixed|null
  * @throws OpenSharedMemoryException
  * @throws ReadSharedMemoryException
  * @throws SupportSharedMemoryException
  */
 public static function read($key, $mode = 0644, $size = 100)
 {
     if (!self::checkSHMOPSupport()) {
         return null;
     }
     @($shm_id = shmop_open($key, "a", $mode, $size));
     //read only
     if (!$shm_id) {
         throw new OpenSharedMemoryException("The shared memory block could not be opened");
     }
     @($cached_string = shmop_read($shm_id, 0, $size));
     if (!$cached_string) {
         shmop_delete($shm_id);
         shmop_close($shm_id);
         throw new ReadSharedMemoryException("The shared memory block could not be read");
     }
     $data = json_decode($cached_string, true);
     if (isset($data['expiration']) && time() > $data['expiration'] || !isset($data['expiration'])) {
         shmop_delete($shm_id);
         shmop_close($shm_id);
         return null;
     }
     shmop_close($shm_id);
     return unserialize($data['value']);
 }

 public function create($key, $buckets = 12281, $size = 10000000)
 {
     if ($key == 0) {
         $this->errmsg = "key is 0";
         return false;
     }
     $this->shmId = @shmop_open($key, 'a', 0, 0);
     if ($this->shmId != false) {
         if (!shmop_delete($this->shmId)) {
             $this->errmsg = 'delete exist shm 0x' . dechex($key) . ' error';
             return false;
         }
     }
     $this->shmId = shmop_open($key, 'c', 0777, $size);
     if ($this->shmId == false) {
         $this->errmsg = 'create shm 0x' . dechex($key) . ' error';
         return false;
     }
     $head['bsize'] = $size;
     $head['size'] = 0;
     $head['buckets'] = $buckets;
     $head['start'] = 24;
     $head['data'] = $buckets * 8 + 24;
     $head['free'] = $buckets * 8 + 24;
     return $this->setHead($head);
 }

 function rm($key)
 {
     $this->shmop_key = ftok($this->pre . $key);
     $this->shmop_id = shmop_open($this->shmop_key, 'c', 0644, 0);
     $result = shmop_delete($this->shmop_id);
     shmop_close($this->shmop_id);
     return $result;
 }

 /**
  * Get all the exceptions added to the shared memory.
  *
  * @return \Throwable[]
  */
 public function getExceptions() : array
 {
     $memory = shmop_open($this->key, "a", 0, 0);
     $exceptions = $this->unserialize($memory);
     shmop_delete($memory);
     shmop_close($memory);
     return $exceptions;
 }

function __unlock()
{
    if (isset($_SERVER['sync'])) {
        shmop_delete($_SERVER['sync']);
        shmop_close($_SERVER['sync']);
        unset($_SERVER['sync']);
    }
}

 /**
  * @return boolean
  */
 public function delete()
 {
     if (!$this->exists()) {
         return true;
     }
     $shmId = shmop_open($this->shmKey, 'w', 0, 0);
     $result = (bool) shmop_delete($shmId);
     shmop_close($shmId);
     return $result;
 }

 public function delete($id, $size)
 {
     $shm = $this->open($id, $size);
     if (shmop_delete($shm)) {
         $keyfile = $this->getKeyFile($id);
         if (file_exists($keyfile)) {
             unlink($keyfile);
         }
     }
     return true;
 }

 public function getCallbackParams()
 {
     $shmId = @shmop_open($this->pid, 'a', 0644, 0);
     if (empty($shmId)) {
         return false;
     }
     $datas = unserialize(shmop_read($shmId, 0, shmop_size($shmId)));
     shmop_delete($shmId);
     shmop_close($shmId);
     return $datas;
 }

 /**
  * delete shared memory
  *
  * @return  void
  * @throws  RuntimeException
  */
 public function delete()
 {
     $s = @shmop_open($this->genKey(), 'a', 0, 0);
     if ($s === false) {
         return;
     }
     if (!shmop_delete($s)) {
         throw new RuntimeException('could not delete shared memory');
     }
     shmop_close($s);
     unlink('/tmp/' . sha1($this->pid));
 }

 public function __destruct()
 {
     if ($this->changed) {
         $serialized = serialize($this->data);
         if (strlen($serialized) > shmop_size($this->res)) {
             shmop_delete($this->res);
             $this->res = shmop_open($id, 'c', 0644, ceil(strlen($serialized) * 1.25));
         }
         shmop_write($this->res, $serialized, 0);
     }
     shmop_close($this->res);
 }

 protected function tearDown()
 {
     if ($shmid = @shmop_open(self::SHMOP_ID, 'w', 0644, 0)) {
         /*
          * Fill memory block for fix bug
          * @link https://bugs.php.net/bug.php?id=71921
          */
         shmop_write($shmid, str_pad('', strlen(self::WORD), ' '), 0);
         shmop_delete($shmid);
         shmop_close($shmid);
     }
 }

 function stream_write($data)
 {
     $p = $this->path;
     $fp = fopen($p, 'w');
     fwrite($fp, $data);
     fclose($fp);
     $this->id = ftok($this->path, 'M');
     if ($t = @shmop_open($this->id, 'a', 0, 0)) {
         shmop_delete($t);
     }
     $t = shmop_open($this->id, 'c', 0755, strlen($data));
     shmop_write($t, $data, 0);
 }