php操作共享内存shmop类及简单使用测试（代码）详解编程语言

<?php 
//类对象 
namespace Simple/SHM; 
 
class Block 
{ 
    /** 
     * Holds the system id for the shared memory block 
     * 
     * @var int 
     * @access protected 
     */ 
    protected $id; 
 
    /** 
     * Holds the shared memory block id returned by shmop_open 
     * 
     * @var int 
     * @access protected 
     */ 
    protected $shmid; 
 
    /** 
     * Holds the default permission (octal) that will be used in created memory blocks 
     * 
     * @var int 
     * @access protected 
     */ 
    protected $perms = 0644; 
 
    /** 
     * Shared memory block instantiation 
     * 
     * In the constructor we'll check if the block we're going to manipulate 
     * already exists or needs to be created. If it exists, let's open it. 
     * 
     * @access public 
     * @param string $id (optional) ID of the shared memory block you want to manipulate 
     */ 
    public function __construct($id = null) 
    { 
        if($id === null) { 
            $this->id = $this->generateID(); 
        } else { 
            $this->id = $id; 
        } 
 
        if($this->exists($this->id)) { 
            $this->shmid = shmop_open($this->id, "w", 0, 0); 
        } 
    } 
 
    /** 
     * Generates a random ID for a shared memory block 
     * 
     * @access protected 
     * @return int System V IPC key generated from pathname and a project identifier 
     */ 
    protected function generateID() 
    { 
        $id = ftok(__FILE__, "b"); 
        return $id; 
    } 
 
    /** 
     * Checks if a shared memory block with the provided id exists or not 
     * 
     * In order to check for shared memory existance, we have to open it with 
     * reading access. If it doesn't exist, warnings will be cast, therefore we 
     * suppress those with the @ operator. 
     * 
     * @access public 
     * @param string $id ID of the shared memory block you want to check 
     * @return boolean True if the block exists, false if it doesn't 
     */ 
    public function exists($id) 
    { 
        $status = @shmop_open($id, "a", 0, 0); 
        return $status; 
    } 
 
    /** 
     * Writes on a shared memory block 
     * 
     * First we check for the block existance, and if it doesn't, we'll create it. Now, if the 
     * block already exists, we need to delete it and create it again with a new byte allocation that 
     * matches the size of the data that we want to write there. We mark for deletion,  close the semaphore 
     * and create it again. 
     * 
     * @access public 
     * @param string $data The data that you wan't to write into the shared memory block 
     */ 
    public function write($data) 
    { 
        $size = mb_strlen($data, 'UTF-8'); 
 
        if($this->exists($this->id)) { 
            shmop_delete($this->shmid); 
            shmop_close($this->shmid); 
            $this->shmid = shmop_open($this->id, "c", $this->perms, $size); 
            shmop_write($this->shmid, $data, 0); 
        } else { 
            $this->shmid = shmop_open($this->id, "c", $this->perms, $size); 
            shmop_write($this->shmid, $data, 0); 
        } 
    } 
 
    /** 
     * Reads from a shared memory block 
     * 
     * @access public 
     * @return string The data read from the shared memory block 
     */ 
    public function read() 
    { 
        $size = shmop_size($this->shmid); 
        $data = shmop_read($this->shmid, 0, $size); 
 
        return $data; 
    } 
 
    /** 
     * Mark a shared memory block for deletion 
     * 
     * @access public 
     */ 
    public function delete() 
    { 
        shmop_delete($this->shmid); 
    } 
 
    /** 
     * Gets the current shared memory block id 
     * 
     * @access public 
     */ 
    public function getId() 
    { 
        return $this->id; 
    } 
 
    /** 
     * Gets the current shared memory block permissions 
     * 
     * @access public 
     */ 
    public function getPermissions() 
    { 
        return $this->perms; 
    } 
 
    /** 
     * Sets the default permission (octal) that will be used in created memory blocks 
     * 
     * @access public 
     * @param string $perms Permissions, in octal form 
     */ 
    public function setPermissions($perms) 
    { 
        $this->perms = $perms; 
    } 
 
    /** 
     * Closes the shared memory block and stops manipulation 
     * 
     * @access public 
     */ 
    public function __destruct() 
    { 
        shmop_close($this->shmid); 
    } 
}

<?php 
//测试使用代码 
namespace Simple/SHM/Test; 
 
use Simple/SHM/Block; 
 
class BlockTest extends /PHPUnit_Framework_TestCase 
{ 
    public function testIsCreatingNewBlock() 
    { 
        $memory = new Block; 
        $this->assertInstanceOf('Simple//SHM//Block', $memory); 
 
        $memory->write('Sample'); 
        $data = $memory->read(); 
        $this->assertEquals('Sample', $data); 
    } 
 
    public function testIsCreatingNewBlockWithId() 
    { 
        $memory = new Block(897); 
        $this->assertInstanceOf('Simple//SHM//Block', $memory); 
        $this->assertEquals(897, $memory->getId()); 
 
        $memory->write('Sample 2'); 
        $data = $memory->read(); 
        $this->assertEquals('Sample 2', $data); 
    } 
 
    public function testIsMarkingBlockForDeletion() 
    { 
        $memory = new Block(897); 
        $memory->delete(); 
        $data = $memory->read(); 
        $this->assertEquals('Sample 2', $data); 
    } 
 
    public function testIsPersistingNewBlockWithoutId() 
    { 
        $memory = new Block; 
        $this->assertInstanceOf('Simple//SHM//Block', $memory); 
        $memory->write('Sample 3'); 
        unset($memory); 
 
        $memory = new Block; 
        $data = $memory->read(); 
        $this->assertEquals('Sample 3', $data); 
    } 
}

<?php 
  
$memory = new SimpleSHM; 
$memory->write('Sample'); 
echo $memory->read(); 
  
?>

<?php 
  
$new = new SimpleSHM(897); 
$new->write('Sample'); 
echo $new->read(); 
  
?>

<?php 
  
require('SimpleSHM.class.php'); 
  
$results = array( 
    'user' => 'John', 
    'password' => '123456', 
    'posts' => array('My name is John', 'My name is not John') 
); 
  
$data = json_encode($results); 
  
$memory = new SimpleSHM; 
$memory->write($data); 
$storedarray = json_decode($memory->read()); 
  
print_r($storedarray); 
  
?>