In this article, we will explore the basics of PHP fibers and learn how to use them to improve the efficiency of our web development projects. We will cover everything from creating a fiber to more advanced features, so you can start leveraging the power of fibers in your own PHP projects.

Fibers are lightweight, full-stack coroutines that allow suspending the current execution of a function and resuming it later, which makes it possible to achieve multi-threading-like behavior. In this article, we will go over the basics of PHP fibers and how to use them.

Creating a php fiber

A fiber is created using the Fiber class. Here is an example of how to create a fiber that echoes a message:

phpCopy code$fiber = new Fiber(function() {
    echo "Hello from the fiber\n";
});

$fiber->start();

In this example, we create a new fiber by passing a callable function to the Fiber constructor. The function is not executed yet, but when we call the start() method, the function will be executed in a new fiber.

Suspending and resuming a php fiber

Fibers can be paused at any point using the Fiber::suspend() method. This method accepts an optional value that can be used to resume the fiber later. Here is an example of how to suspend and resume a fiber:

phpCopy code$fiber = new Fiber(function() {
    echo "Fiber started\n";
    Fiber::suspend("Value passed to resume\n");
    echo "Fiber resumed\n";
});

$fiber->start();
echo "Fiber suspended with value: " . $fiber->getCurrentValue() . "\n";
$fiber->resume();

In this example, we create a new fiber that echoes “Fiber started”, suspends itself using Fiber::suspend(), and echoes “Fiber resumed” when it is resumed. We start the fiber, and it prints “Fiber started”. We then get the current value of the fiber using getCurrentValue(), which should return null because the fiber is suspended. Finally, we resume the fiber, and it prints “Fiber resumed” and exits.

Passing values to a php fiber

When a fiber is started, it can accept an optional parameter that is passed to the callable function. Here is an example of how to pass a parameter to a fiber:

phpCopy code$fiber = new Fiber(function($name) {
    echo "Hello $name\n";
});

$fiber->start("John");

In this example, we create a new fiber that accepts a parameter called “name” and echoes “Hello $name”. We start the fiber with the parameter “John”, and it prints “Hello John”.

Creating simple rate-limited API request system using PHP fibers

In this example, we’ll create a simple rate-limited API request system using PHP fibers. We’ll be sending requests to an API with a limit of 5 requests per second. If the limit is reached, fibers will help us pause the execution until we can send the next request.

<?php

use \Fiber;

class RateLimiter {
    private int $maxRequestsPerSecond;
    private float $lastRequestTime;
    private Fiber $limiter;

    public function __construct(int $maxRequestsPerSecond) {
        $this->maxRequestsPerSecond = $maxRequestsPerSecond;
        $this->lastRequestTime = microtime(true);

        $this->limiter = new Fiber(function () {
            while (true) {
                $currentTime = microtime(true);
                $timeSinceLastRequest = $currentTime - $this->lastRequestTime;

                if ($timeSinceLastRequest < 1 / $this->maxRequestsPerSecond) {
                    usleep((int) ((1 / $this->maxRequestsPerSecond - $timeSinceLastRequest) * 1000000));
                }

                $this->lastRequestTime = microtime(true);
                Fiber::suspend();
            }
        });

        $this->limiter->start();
    }

    public function request(callable $apiCall) {
        $this->limiter->resume();
        return $apiCall();
    }
}

$rateLimiter = new RateLimiter(5);

$apiCall = function () {
    // Simulate an API call
    echo "API request sent at " . microtime(true) . PHP_EOL;
};

for ($i = 0; $i < 10; $i++) {
    $rateLimiter->request($apiCall);
}

Running this example will give something like :

$ php rate-limiter-api.php
API request sent at 1678996902.2899
API request sent at 1678996902.4936
API request sent at 1678996902.6969
API request sent at 1678996902.8985
API request sent at 1678996903.1006
API request sent at 1678996903.3031
API request sent at 1678996903.5055
API request sent at 1678996903.7094
API request sent at 1678996903.9142
API request sent at 1678996904.116

In this example, we have a RateLimiter class that takes the maximum number of requests per second as a parameter. It has a request method that takes a callable representing the API call. The rate limiter ensures that we don’t exceed the allowed number of requests per second by using fibers to pause the execution if necessary.

When the RateLimiter object is created, it starts a fiber that runs in an infinite loop. Inside the loop, it checks the time since the last request and sleeps if it’s too soon to send the next request. After sleeping, it updates the last request time and suspends the fiber.

When the request method is called, it resumes the fiber, which ensures we don’t exceed the rate limit. After the fiber is resumed, it calls the API function provided.

The example demonstrates how PHP fibers can be used to solve real-world problems like rate limiting in a simple and efficient manner.

Conclusion

In conclusion, fibers introduce a powerful and efficient mechanism for concurrent programming in PHP. This article provided an overview of PHP fibers, covering fundamental aspects like creating, suspending, and resuming fibers, as well as passing values to them. We also demonstrated a practical use case by implementing a rate-limited API request system. To further harness the potential of fibers, we encourage you to delve into the official documentation and experiment with this feature in your PHP projects.

Strategy Pattern

The Strategy pattern is a behavioral pattern that allows objects to change their behavior dynamically at runtime by encapsulating a family of algorithms and making them interchangeable. In other words, it enables the selection of an algorithm at runtime depending on the context.

Let’s consider a simple game where the player can choose from different characters with different abilities. For example, we have a knight, a wizard, and an archer. Each character has a unique set of abilities that can be used during the game.

To implement the Strategy pattern in this game, we can create an interface called CharacterAbility that defines a common method called useAbility(). This method will be implemented differently for each character class that we have. Here’s an example of the CharacterAbility interface:

interface CharacterAbility {
    public function useAbility();
}

Next, we can create different character classes, each implementing the CharacterAbility interface with their own implementation of the useAbility() method. For example, we can create the Knight class as follows:

class Knight implements CharacterAbility {
    public function useAbility() {
        // Implement the knight's ability here
    }
}

Similarly, we can create the Wizard and Archer classes with their own implementation of the useAbility() method.

Now, let’s say the player has selected a character, and we need to use their ability during the game. We can create a Game class that will receive the selected character as a parameter and use their ability during the game. However, we don’t want to hardcode the ability inside the Game class because we want to make it interchangeable. This is where the Strategy pattern comes in.

We can create another interface called AbilityStrategy that will define the useAbility() method, which takes the character object as a parameter. This interface will be implemented by different strategy classes, each representing a specific ability of the character. For example, we can create the KnightAbilityStrategy class as follows:

class KnightAbilityStrategy implements AbilityStrategy {
    public function useAbility($character) {
        $character->useAbility(); // Use the knight's ability
    }
}

Similarly, we can create the WizardAbilityStrategy and ArcherAbilityStrategy classes with their own implementation of the useAbility() method.

Finally, in the Game class, we can set the ability strategy based on the selected character. For example:

class Game {
    private $abilityStrategy;
    
    public function setAbilityStrategy($character) {
        if ($character instanceof Knight) {
            $this->abilityStrategy = new KnightAbilityStrategy();
        } else if ($character instanceof Wizard) {
            $this->abilityStrategy = new WizardAbilityStrategy();
        } else if ($character instanceof Archer) {
            $this->abilityStrategy = new ArcherAbilityStrategy();
        }
    }
    
    public function useAbility() {
        $this->abilityStrategy->useAbility($character);
    }
}

Now, whenever the player selects a character, we can set the ability strategy accordingly using the setAbilityStrategy() method, and the useAbility() method will call the correct ability based on the selected character. This way, we can make the abilities interchangeable without modifying the Game class.

In conclusion, the Strategy pattern allows us to encapsulate different algorithms or behaviors and make them interchangeable at runtime, without affecting the client code. This makes our code more flexible and maintainable, and it is particularly useful in games where different characters have different abilities that can be used in different contexts.