public function write($key, $value)
 {
     if ($this->shmId) {
         return shm_put_var($this->shmId, $key, $value);
     }
     return false;
 }

function Map2GE($x, $y)
{
    if (0) {
        $SHM_KEY = ftok(__FILE__, chr(4));
        $data = shm_attach($SHM_KEY, 102400, 0666);
        $result = shm_get_var($data, 1);
        $r = $result[$x][$y];
        if (isset($r)) {
            shm_detach($data);
            return $r;
        }
    }
    // ­×¥¿
    $r = t67to97($x, $y);
    $x = $r[0];
    $y = $r[1];
    $proj = "proj -I +proj=tmerc +ellps=aust_SA +lon_0=121 +x_0=250000 +k=0.9999";
    $ret = shell_exec("echo {$x} {$y} | {$proj}");
    if (preg_match("/(\\d+)d(\\d+)'([\\d.]+)\"E\\s+(\\d+)d(\\d+)'([\\d.]+)\"N/", $ret, $matches)) {
        list($junk, $ed, $em, $es, $nd, $nm, $ns) = $matches;
        $r[0] = $ed + $em / 60 + $es / 3600;
        $r[1] = $nd + $nm / 60 + $ns / 3600;
        if (0) {
            $result[$x][$y] = $r;
            shm_put_var($data, 1, $result);
            shm_detach($data);
        }
        return $r;
    }
    return FALSE;
    // exit;
}

 public function set($key, $value, $no_cas = false)
 {
     if (!$this->isOpen()) {
         $this->open();
     }
     $this->enterCriticalSection($this->ipckey);
     $this->debug("SHM set: {$key} = {$value}");
     $key = strtolower($key);
     $idx = $this->props[$key];
     if (!$no_cas && shm_has_var($this->shm, $idx) && !empty($this->hashes[$key])) {
         $var = shm_get_var($this->shm, $idx);
         $check = md5($var);
         if ($this->hashes[$key] == $check) {
             $this->debug("CAS check: Key not modified: {$key}");
             shm_put_var($this->shm, $idx, $value);
             $ok = true;
         } else {
             $this->debug("CAS check: Key modified, write blocked: {$key}");
             $ok = false;
         }
     } else {
         $this->debug("CAS check: Check disabled for set: {$key}");
         $ok = true;
         shm_put_var($this->shm, $idx, $value);
     }
     if ($ok) {
         $hash = md5($value);
         $this->hashes[$key] = $hash;
         $this->debug("CAS hash for {$key} is now {$hash}");
     }
     $this->leaveCriticalSection();
     return $ok;
 }

 /**
  * @return IdValue
  */
 public function generate()
 {
     $timestamp = $this->generateTimestamp();
     // Acquire semaphore
     $semaphore = sem_get($this->semaphoreId);
     sem_acquire($semaphore);
     // Attach shared memory
     $memory = shm_attach(self::SHM_KEY);
     $sequence = 0;
     if (!is_null($this->lastTimestamp) && $timestamp->equals($this->lastTimestamp)) {
         // Get
         $sequence = shm_get_var($memory, self::SHM_SEQUENCE) + 1 & $this->config->getSequenceMask();
         // Increment sequence
         shm_put_var($memory, self::SHM_SEQUENCE, $sequence);
         if ($sequence === 0) {
             usleep(1000);
             $timestamp = $this->generateTimestamp();
         }
     } else {
         // Reset sequence if timestamp is different from last one.
         $sequence = 0;
         shm_put_var($memory, self::SHM_SEQUENCE, $sequence);
     }
     // Detach shared memory
     shm_detach($memory);
     // Release semaphore
     sem_release($semaphore);
     // Update lastTimestamp
     $this->lastTimestamp = $timestamp;
     return new IdValue($timestamp, $this->regionId, $this->serverId, $sequence, $this->calculate($timestamp, $this->regionId, $this->serverId, $sequence));
 }

 /**
  * (non-PHPdoc)
  * @see Lexik\Bundle\MaintenanceBundle\Drivers.AbstractDriver::createLock()
  */
 protected function createLock()
 {
     if ($this->shmId) {
         return shm_put_var($this->shmId, self::VARIABLE_KEY, self::VALUE_TO_STORE);
     }
     return false;
 }

/**
 * 通过本机共享内存件来生成一个auto_increment序列
 *
 * 序列类似MySQL的auto_increment
 *
 * @access private
 * @param  void
 * @return mixed
 */
function getNextValueByShareMemory()
{
    $addr = '127.0.0.1';
    if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
        $addr = $_SERVER['HTTP_X_FORWARDED_FOR'];
    } elseif (!empty($_SERVER['SERVER_ADDR'])) {
        $addr = $_SERVER['SERVER_ADDR'];
    }
    $skey = 'global_serial_generator_seed_' . $addr;
    $ikey = crc32($skey);
    $sem = $shm = null;
    $retry_times = 1;
    do {
        $sem = sem_get($ikey, 1, 0777);
        $shm = shm_attach($ikey, 128, 0777);
        if (is_resource($sem) && is_resource($shm)) {
            break;
        }
        $cmd = "ipcrm -M 0x00000000; ipcrm -S 0x00000000; ipcrm -M {$ikey} ; ipcrm -S {$ikey}";
        $last_line = exec($cmd, $output, $retval);
    } while ($retry_times-- > 0);
    if (!sem_acquire($sem)) {
        return false;
    }
    $next_value = false;
    if (shm_has_var($shm, $ikey)) {
        shm_put_var($shm, $ikey, $next_value = shm_get_var($shm, $ikey) + 1);
    } else {
        shm_put_var($shm, $ikey, $next_value = 1);
    }
    $shm && shm_detach($shm);
    $sem && sem_release($sem);
    return $next_value;
}

 /**
  * @param $key
  * @param $value
  * @param int $size
  */
 public function set($key, $value, $size = 10000)
 {
     $result = $this->attach($key, $size);
     sem_acquire($result['mutex']);
     shm_put_var($result['shm'], $key, $value);
     sem_release($result['mutex']);
 }

 /**
  * @author Yohann Marillet
  */
 public function put($key = 1, $value = true)
 {
     $res = shm_put_var($this->segment, $key, [$value]);
     if (!$res) {
         throw new \Exception('Cannot put data in semaphore');
     }
     return $this;
 }

 /**
  * @see CachePeer::set()
  *
  * @return SysVCachePeer
  */
 function set($key, $value, $ttl = CacheTtl::HOUR)
 {
     Assert::isNumeric($ttl);
     if ($this->isAlive()) {
         shm_put_var($this->getSegmentPtr(), $this->key2int($key), array(self::FIELD_EXPIRES => time() + $ttl, self::FIELD_DATA => $value));
     }
     return $this;
 }

 public function set()
 {
     $lock = $this->check();
     if ($lock) {
         throw new Exception('Core_Lock_Shm::set Failed. Existing Lock Detected from PID ' . $lock['pid']);
     }
     shm_put_var($this->shm, self::ADDRESS, array('pid' => $this->pid, 'time' => time()));
 }

 /**
  * Set shared memory var
  * @param $var
  */
 public function set($var)
 {
     sem_acquire($this->__mutex);
     //block until released
     shm_put_var($this->__shm, $this->__key, $var);
     //store var
     sem_release($this->__mutex);
     //release mutex
 }

 public function set($index, $value, $overwrite = false)
 {
     if ($overwrite || !shm_has_var($this->shm, $index) || $this->data[$index] == shm_get_var($this->shm, $index)) {
         shm_put_var($this->shm, $index, $value);
         return true;
     } else {
         return false;
     }
 }

 /**
  * if an error like "not enough shared memory left" occurs then set  sysvshm.init_mem to a higher value
  * Lock process without blocking.
  * This method allow protect multiple process running and fast lock validation.
  *
  */
 public function lock()
 {
     $success = sem_acquire($this->_getSemIdentifier());
     shm_put_var($this->_shmId, $this->getIndexerCodeCrc(), $this->_getMicrotimeString());
     if (false === $success) {
         Mage::throwException('FastIndexer: Cannot acquire semaphore lock!');
     }
     $this->_isLocked = true;
 }

 public static function store($key, $value)
 {
     self::getHandle();
     if (!shm_put_var(self::$handle, self::getVarKey($key), $value)) {
         sem_remove(self::$semaphore);
         shm_remove(self::$handle);
         die('couldn\'t write to shared memory.');
     }
     self::release();
 }

 public function run()
 {
     $this->synchronized(function ($thread) {
         $thread->wait();
     }, $this);
     $counter = shm_get_var($this->shmid, 1);
     $counter++;
     shm_put_var($this->shmid, 1, $counter);
     printf("Thread #%lu says: %s\n", $this->getThreadId(), $counter);
 }

 /**
  * Put this segment's contents
  *
  * @param   var data
  * @param   int permissions default 0666 permissions
  * @return  bool success
  * @throws  io.IOException in case an error occurs
  */
 public function put($val, $permissions = 0666)
 {
     $v = [$val];
     $h = shm_attach($this->spot, (strlen(serialize($v)) + 44) * 2, $permissions);
     $ret = shm_put_var($h, $this->name, $v);
     shm_detach($h);
     if (false === $ret) {
         throw new IOException('Could not write segment ' . $this->name);
     }
     return $ret;
 }

 public function __destruct()
 {
     if ($this->changed) {
         if (shm_put_var($this->res, self::DEFAULT_VAR_ID, $this->data) === false) {
             $length = strlen($this->data);
             shm_remove($this->res);
             $this->res = shm_attach($this->id, ceil($length * 1.25));
             shm_put_var($this->res, self::DEFAULT_VAR_ID, $this->data);
         }
     }
     shm_detach($this->res);
 }

 /**
  * @param int $pid
  *
  * @return int
  */
 private function readInc($pid)
 {
     $res = shm_attach($pid);
     if (!shm_has_var($res, 0)) {
         shm_put_var($res, 0, 0);
     }
     $inc = shm_get_var($res, 0);
     if ($inc === 16777215) {
         $inc = 0;
     }
     ++$inc;
     shm_put_var($res, 0, $inc);
     return $inc;
 }

 public function put_var($varname, $value, $autolock = FALSE)
 {
     $varkey = $this->_gen_key($varname);
     if ($autolock) {
         sem_acquire($this->sem);
     }
     $result = shm_put_var($this->shm_id, $varkey, $value);
     if ($autolock) {
         sem_release($this->sem);
     }
     return $result;
     // 写入失败：空间不够或其它异常，删除共内存中所有值
     //if (!shm_remove($this->shm_id)) return FALSE;
     //return shm_put_var($this->shm_id, $varkey, $value);
 }

 function squabble()
 {
     global $handle;
     global $buffer;
     $i = 0;
     $pid = getmypid();
     while (true) {
         if (preg_match("/^{$pid}\\b/", shm_get_var($buffer, 1))) {
             continue;
         }
         sem_acquire($handle);
         $i++;
         shm_put_var($buffer, 1, "{$pid} {$i}");
         sem_release($handle);
     }
 }