Concurrency Process Driver: using closures with bindings

[sadiqsalau]

Laravel Version

12.4.1

PHP Version

8.4.5

Database Driver & Version

No response

Description

When using the process driver with a closure that uses $this , the call fails with the error:
Cannot assign Laravel\\SerializableClosure\\Serializers\\Native to property Symfony\\Component\\Console\\Input\\InputArgument::$suggestedValues of type Closure|array

At first i thought the issue was from my macro

public function boot(): void
{
    Collection::macro('mapForConcurrency', function ($callback) {
        /** @var Collection $this */
        return $this->map(fn($value, $key) => fn() => $callback($value, $key))->all();
    });
}

So I narrowed it down to a simple call:

$closure = fn() => $this->getTitle();
$results = Concurrency::run([$closure]);
dump($results);

Switching to the fork driver works without issues.

$results = Concurrency::driver('fork')->run([$closure]);

Steps To Reproduce

Any closure that make use of $this fails.

class Example {
	public function test(){
		$closure = fn() => $this->getTitle();
		$results = Concurrency::run([$closure]);
		dump($results);
	}

	public function getTitle(){
		return 'Title';
	}
}

[macropay-solutions]

Is this supposed to be a feature of concurrency? Concurrency does not share the php process.

[AndrewMast]

The process driver serializes the closures in order to run them.

However, there are some caveats to serializing closures:

• Anonymous classes cannot be created within closures.
• Attributes cannot be used within closures.
• Serializing closures on REPL environments like Laravel Tinker is not supported.
• Serializing closures that reference objects with readonly properties is not supported.

The issue you have found is a known caveat, but we should probably add a disclaimer to the documentation to highlight this.

Here is an example command to show how using a property causes an error:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Laravel\SerializableClosure\SerializableClosure;

class SerializeClosure extends Command {
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'app:serialize-closure';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Testing serializing closures!';

    /**
     * Execute the console command.
     */
    public function handle() {
        SerializableClosure::setSecretKey('secret');

        // Normal closure

        $closure = fn () => 'james';

        $this->info($closure()); // 'james'

        $serialized = serialize(new SerializableClosure($closure));
        $newClosure = unserialize($serialized)->getClosure();

        $this->info($newClosure()); // 'james'

        // Now to try with property

        $closure = fn () => $this->description; // Uses a property

        $this->info($closure()); // 'Testing serializing closures!'

        $serialized = serialize(new SerializableClosure($closure)); // Throws an error!

        // Cannot assign Laravel\SerializableClosure\Serializers\Native to property...

        $newClosure = unserialize($serialized)->getClosure();

        $this->info($newClosure()); // Not reached due to error
    }
}

[AndrewMast]

Your issue reminded me of a recent tweet by Steve Bauman:

Since you can't use "$this" in a serialized closure, consider extracting your Closure based Bus::batch callbacks to Callable classes

With this method:

• You don't need to create local variables associated to "$this" properties to make them serializable in the closure
• Keeps your job minimal, splitting responsibilities
• Extracts the logic into its own testable class

[sadiqsalau]

@AndrewMast I have tried implementing something close to your suggesstion, but it just doesn't work with the process driver. I have settled with the fork driver.

My Full API:

// AppServiceProvider

Collection::macro('mapForConcurrency', function ($callback) {
    /** @var Collection $this */
    return $this->map(fn($value, $key) => fn() => $callback($value, $key))->all();
});


// ExampleClass
/**
 * Run Concurrently
 * @param Closure|array $tasks
 * @return \Illuminate\Support\Collection
 */
protected function runConcurrently($tasks)
{
    return collect(
        Concurrency::driver('fork')->run(
            $tasks
        )
    );
}

// Example Call
$this->runConcurrently(
	collect([1,2,3])->mapForConcurrency(function($seconds){
		$this->sleepFor($seconds);
	})
);

[AndrewMast]

You are still using $this in your closures that get serialized, the process driver can't do that.