Implement inter-process communication in PHP

Implement inter-process communication in PHP

Qiu Wenyu

This article will discuss how to use the inter-process communication mechanism-IPC (inter-process-communication) in the PhP4 environment ). The software environment discussed in this article is Linux + php4.0.4 or later. First, assume that you have installed PhP4 and Unix. To enable PhP4 to use shared memory and semaphores, you must compile PhP4 Program Activate the shmop and sysvsem extension modules.
Implementation Method: Add the following options When configuring configure in PHP.
-- Enable-shmop -- enable-sysvsem
This allows your PHP system to process related IPC functions.
What is IPC?
IPC (inter-process communication) is a UNIX standard communication mechanism, which provides a method for communication between different processes on the same host. There are three basic IPC processing mechanisms: Shared Memory, semaphore, and message queue. This article mainly discusses the use of shared memory and semaphores. I will introduce the message queue in the near future.
Use shared memory segments in PHP
Using shared memory between different processing processes is a good way to achieve mutual communication between different processes. If you write a piece of information to the shared memory in a process, all other processes can also see the written data. Very convenient. With the help of shared memory in PHP, You can implement different processes to return different results when running the same PHP script. Or real-time query of the number of concurrent PHP operations.
Shared memory allows two or more processes to share a given storage zone. Because data does not need to be copied between the client and the server, this is the fastest IPC. The only trick to using shared memory is the synchronous access of multiple processes to a given storage zone.
How to create a shared memory segment? The following Code You can create shared memory for you.
$ Shm_id = shmop_open ($ key, $ mode, $ perm, $ size );
Note that each shared memory segment has a unique ID. in PHP, shmop_open returns the ID of the created shared memory segment. Here we use $ shm_id to record it. $ Key is a key value that logically represents the shared memory segment. Different processes can share the same bucket with the same key ID. Traditionally, we use the hash value of a string (something similar to a file name) as the key ID. $ mode to indicate how to use the shared memory segment. Here, because it is a new one, the value is 'C'-the meaning of "CREATE. If you are accessing the shared memory that has been created, use 'A', -- the meaning of access. The $ perm parameter defines the access permission in octal mode. For the permission definition, see the Unix File System Help. $ Size defines the size of the shared memory. Although it is a bit like fopen (File Processing), you should not treat it like file processing. You will see a bit later.
For example:
$ Shm_id = shmop_open (0xff3, "C", 0644,100 );
Here we open a shared memory segment key value 0xff3-RW-r-format, the size is 100 bytes.
To access an existing shared memory segment, you must set the 3rd and 4 parameters to 0 in the call to shmop_open.
Query the IPC working status
In UNIX, you can use the command line program IPCS to query the status of all IPC resources. However, some systems require super users to execute them. Is the running result of a piece of IPCS.

The system displays four shared memory segments. Note that the 4th key values 0x00000ff3 are created by the PHP program we just run. For instructions on IPCS usage, refer to the Unix user manual.
How to release the shared memory?
To release the shared memory, call the php Command: shmop_delete ($ id)
Shmop_delete ($ id );
$ ID is the return value of the shmop_op stored in the call shmop_open. Another way is to use Unix management commands:
Ipcrm ID. ID is the ID you see in IPCS. It is different from $ ID in your program. But be careful, if you use ipcrm to directly Delete shared memory segments, other processes that do not know this situation may encounter some unpredictable Errors When referencing this no longer-existing shared memory device (often bad results ).
How to Use (read/write) shared memory?
Use the following function to write data to the shared memory:
Int shmop_write (INT shmid, string data, int offset)
Here, shmid uses the handle returned by shmop_open. $ Data variable stores the data to be stored. $ Offset describes the position of the first byte from the beginning of the shared memory (starting with 0 ).
The read operation is:
String shmop_read (INT shmid, int start, int count)
Similarly, specify $ shmid, start offset (starting from 0), and total number of reads. Return result string. In this way, you can regard the shared memory segment as a byte array. It is very convenient to read a few and write a few more.
Multi-process considerations
Now, in a separate rose uncover the yellow and yellow, the yellow and the yellow, the yellow? The data written by processes appears randomly in turn. This is obviously unacceptable. To solve this problem, we must introduce the mutex mechanism. The mutex mechanism is described in many operating system textbooks. The simplest way to implement mutex is to use traffic signals. Semaphores are another way of inter-process communication (IPC), which is different from other IPC organizations (pipelines, FIFO, message queues. It is a stenographer used to control the storage of shared data by multiple processes. Similarly, you can use IPCS and ipcrm to query the traffic signal Usage Status and delete it. In PHP, you can use the following functions to create a new semaphore and return the handle to operate the semaphore. If the semaphore to which the key points already exists, sem_get directly returns the handle to operate the semaphore.
Int sem_get (INT key [, int max_acquire] [, int perm])
$ Max_acquire indicates that a maximum of several processes can enter the signal at the same time without waiting for the signal to be released (that is, the maximum number of processes that process a resource at the same time. Generally, this value is one ). $ Perm indicates the access permission.
Once you successfully have a semaphore, there are only two types of semaphore that you can do: request and release. When you perform the release operation, the system will reduce the signal value by one. If it is less than 0, it is also set to 0. When you execute the request, the system will increase the value of this signal. If the value is greater than the set maximum value, the system will suspend your processing process until other processes are released to a value less than the maximum value. Generally, the maximum value is set to 1, in this way, when a process receives a request, other processes can only wait for it to exit the mutex zone and release the semaphore to enter the mutex zone and set it to the exclusive mode at the same time. Such semaphores are often called two-state semaphores. Of course, if the initial value is any positive number, it indicates how many shared resource units are available to the shared application.
The PHP format for application and release operations is as follows:
Int sem_acquire (INT sem_identifier) Application
Int sem_release (INT sem_identifier) released
Specifically, sem_identifier is the return value (handle) of sem_get ).
An example of a simple mutex Protocol
The following is a simple mutex operation procedure.
$ Semid = sem_get (0xee3, 1,0666 );
$ Shm_id = shmop_open (0xff3, "C", 0644,100 );
Sem_acquire ($ Semid); // apply
/* Enter the critical section */
Here, the shared memory is processed
Sem_release ($ Semid); // release
As you can see, the implementation of mutex is very simple: Apply to enter the critical section, perform operations on the resources in the critical section (such as modifying the shared memory) to exit the critical section and release the signal. In this way, it is impossible for two processes to operate on the same shared memory segment at the same time. Because the semaphore mechanism ensures that a time slice can only be entered by one process, other processes must wait until the current process is completed before entering.
A critical section is a code segment that does not allow concurrent processing by multiple processes at the same time.
Note: in PHP, the semaphore occupied by the same process must be released. In a general system, processes are allowed to release signals occupied by other processes. When writing code in the critical section, be sure to carefully design the allocation of resources to avoid deadlock between A, B, and.
Application
IPC is widely used. For example, you can save a complex configuration file or user with specific settings between different processes to avoid repeated processing. I also used the shared memory technology to put a large number of files that must be referenced by a large number of PHP scripts into the shared memory, which significantly improves the Web service speed and eliminates some bottlenecks. There are also chat rooms and multi-channel broadcasts for its use. The power of IPC depends on the size of your imagination. It is a great honor for me to give you some inspiration in this article. I 'd like you to discuss this fascinating computer technology. Email: qwyaxm@163.net