Shared vs Non-Shared Objects

Shared Objects (Singletons)

By default, ObjectManager returns the same instance:

$service1 = $objectManager->get(WarrantyService::class);
$service2 = $objectManager->get(WarrantyService::class);
// $service1 === $service2 (same object)

Non-Shared Objects

Creates new instance each time:

$warranty1 = $objectManager->create(Warranty::class);
$warranty2 = $objectManager->create(Warranty::class);
// $warranty1 !== $warranty2 (different objects)

Configuration

<!-- Default: shared -->
<type name="Amazon\Prep\Service\WarrantyService"/>

<!-- Explicitly non-shared -->
<type name="Amazon\Prep\Model\Warranty" shared="false"/>

<!-- Override to shared -->
<type name="Amazon\Prep\Helper\Data" shared="true"/>

Visual Comparison

Shared (Singleton):
  ObjectManager -> [Same Instance] -> All consumers
  Consumer A --+
               +--> Same WarrantyService
  Consumer B --+

Non-Shared:
  ObjectManager -> [New Instance] -> Each consumer
  Consumer A -> New Warranty
  Consumer B -> New Warranty (different)

Use Shared Objects When

1. Stateless services

class WarrantyService
{
    public function process(Warranty $warranty): void
    {
        // Only uses passed objects, no internal state
    }
}

2. Configuration holders

class ConfigService
{
    public function __construct(
        private ScopeConfigInterface $config
    ) {}

    public function getValue(string $path): mixed
    {
        return $this->config->getValue($path);
    }
}

3. Factories and helpers

// Factory itself is shared, objects it creates are new
$factory = $objectManager->get(WarrantyFactory::class);

4. Cache and session managers

// Must be shared to maintain state
$session = $objectManager->get(CustomerSession::class);

Use Non-Shared Objects When

1. Models with data

$warranty1 = $warrantyFactory->create();
$warranty1->setName('Warranty 1');

$warranty2 = $warrantyFactory->create();
$warranty2->setName('Warranty 2');
// Different objects with different data

2. Collections

$collection1 = $collectionFactory->create();
$collection1->addFieldToFilter('status', 'active');

$collection2 = $collectionFactory->create();
$collection2->addFieldToFilter('status', 'inactive');

3. Request/response objects

$request = $this->requestFactory->create();

4. Data transfer objects

$dto = $this->dtoFactory->create(['data' => $specificData]);

Stateful Shared Objects

Shared objects can accumulate state within a process:

// BAD: Shared object with mutable state
class BadService
{
    private $cache = [];  // Accumulates over time

    public function process($key, $value)
    {
        $this->cache[$key] = $value;  // Never cleared!
    }
}

Stateless Shared Objects

// GOOD: Shared object without mutable state
class GoodService
{
    public function process($key, $value)
    {
        return $this->doWork($key, $value);
    }
}

Resetting Shared State

class CacheService
{
    private $cache = [];

    public function reset(): void
    {
        $this->cache = [];
    }
}

// Call periodically or in tests
$cacheService->reset();

Request Lifecycle

In web requests, shared instances are typically reset between requests:

Request 1 -> Shared instance created -> Response -> Instance destroyed
Request 2 -> New shared instance created -> Response -> Instance destroyed

Exception: Long-running processes (Swoole, queues) keep instances alive.

Thread Safety

In multi-threaded environments (Swoole, etc.):

// Each thread gets its own ObjectManager instance
// Shared instances are per-thread, not global

// Thread 1:
$service1 = ObjectManager::getInstance()->get(Service::class);

// Thread 2:
$service2 = ObjectManager::getInstance()->get(Service::class);
// $service1 !== $service2 (different threads)

Best Practices

Default Patterns

<!-- Services: shared (default) -->
<type name="Amazon\Prep\Service\WarrantyService"/>

<!-- Models: non-shared -->
<type name="Amazon\Prep\Model\Warranty" shared="false"/>

<!-- Collections: non-shared -->
<type name="Amazon\Prep\Model\ResourceModel\Warranty\Collection" shared="false"/>

<!-- Factories: shared -->
<type name="Amazon\Prep\Model\WarrantyFactory"/>

Quick Reference

Debugging Shared Instances

// Check if same instance
$ref1 = spl_object_hash($service1);
$ref2 = spl_object_hash($service2);
echo $ref1 === $ref2 ? 'Same' : 'Different';

// List shared instances in ObjectManager
// (Debug tool required)

Common Mistakes

1. Mutable state in shared objects
2. Using shared for models (data bleeds between requests)
3. Using non-shared for services (wasted resources)
4. Forgetting factory is shared (creates objects, doesn't become object)