【PHP8.x】WeakReference::__construct()メソッドの使い方

Copy
1<?php
2
3/**
4 * 弱い参照の対象となるオブジェクトの例。
5 * オブジェクトが破棄されたことを示すために、__destruct メソッドを含みます。
6 */
7class MyReferencedObject
8{
9    public string $id;
10
11    public function __construct(string $id)
12    {
13        $this->id = $id;
14        echo "MyReferencedObject '{$this->id}' が作成されました。\n";
15    }
16
17    public function __destruct()
18    {
19        echo "MyReferencedObject '{$this->id}' が破棄されました。\n";
20    }
21}
22
23/**
24 * PHP 8のコンストラクタプロパティプロモーションと WeakReference の使用例。
25 * このクラスは、別のオブジェクトへの弱い参照を保持します。
26 */
27class WeakReferenceContainer
28{
29    /**
30     * PHP 8のコンストラクタプロパティプロモーションを使用し、
31     * WeakReference のインスタンスをプライベートプロパティとして定義・初期化します。
32     *
33     * @param WeakReference $weakRef 保持する WeakReference インスタンス。
34     */
35    public function __construct(private WeakReference $weakRef)
36    {
37        // プロパティプロモーションにより、コンストラクタ本体はシンプルに保たれます。
38    }
39
40    /**
41     * 指定されたオブジェクトへの弱い参照を持つ WeakReferenceContainer の新しいインスタンスを生成します。
42     *
43     * @param object $objectToRefer 弱く参照する対象のオブジェクト。
44     * @return self 新しい WeakReferenceContainer のインスタンス。
45     */
46    public static function create(object $objectToRefer): self
47    {
48        // WeakReference::__construct を使用して、指定されたオブジェクトへの弱い参照を作成します。
49        // PHP 8 では WeakReference のコンストラクタが public になりました。
50        return new self(new WeakReference($objectToRefer));
51    }
52
53    /**
54     * 弱い参照が指すオブジェクトを取得します。
55     * オブジェクトがまだメモリ上に存在すればそのオブジェクトを、
56     * すでにガベージコレクションされていれば null を返します。
57     *
58     * @return object|null 参照されているオブジェクト、または null。
59     */
60    public function getReferencedObject(): ?object
61    {
62        return $this->weakRef->get();
63    }
64}
65
66// --- サンプルコードの実行 ---
67
68echo "--- 1. オブジェクトの作成と弱参照の保持 ---\n";
69// 1. 強参照を持つオブジェクトを作成します。
70$myObject = new MyReferencedObject("Data-123");
71
72// 2. WeakReferenceContainer を作成し、myObject への弱い参照を保持させます。
73//    この時、WeakReferenceContainer::create() メソッド内で WeakReference::__construct が呼び出され、
74//    WeakReferenceContainer のコンストラクタではプロパティプロモーションが利用されています。
75$container = WeakReferenceContainer::create($myObject);
76
77echo "WeakReferenceContainer は現在、オブジェクトを弱参照しています。\n";
78if ($container->getReferencedObject() !== null) {
79    echo "弱参照からオブジェクトを取得: ID " . $container->getReferencedObject()->id . "\n";
80} else {
81    echo "弱参照はオブジェクトを保持していません。\n";
82}
83
84echo "\n--- 2. 元のオブジェクトへの強参照を解除 ---\n";
85// 3. 元のオブジェクト ($myObject) への強参照を解除します。
86//    これにより、他にこのオブジェクトへの強参照が存在しなければ、
87//    オブジェクトはガベージコレクションの対象になります。
88unset($myObject);
89echo "元のオブジェクト ($myObject) への強参照を解除しました。\n";
90
91// 注意: PHPのガベージコレクションは非決定的であり、いつ実行されるかは保証されません。
92
93echo "\n--- 3. 弱参照の状態を確認 ---\n";
94// 4. 弱参照からオブジェクトを再取得しようとします。
95//    オブジェクトがガベージコレクションされていれば null が返されます。
96if ($container->getReferencedObject() === null) {
97    echo "弱参照はオブジェクトを保持していません（オブジェクトはガベージコレクションされた可能性が高いです）。\n";
98} else {
99    echo "弱参照はまだオブジェクトを保持しています（ガベージコレクションがまだ行われていない可能性があります）。\n";
100    echo "再取得したオブジェクトID: " . $container->getReferencedObject()->id . "\n";
101}
102
103echo "\n--- サンプルコード終了 ---\n";
104
105?>

WeakReference::__constructは、PHP 8で導入された、オブジェクトへの「弱い参照」を作成するためのコンストラクタです。通常の参照（強参照）と異なり、弱い参照は参照先のオブジェクトがメモリから解放（ガベージコレクション）されるのを妨げません。これにより、オブジェクトの生存期間に影響を与えずに参照を保持したい場合に利用されます。

引数としてobject $objectを受け取ります。この引数には、弱く参照したいオブジェクトのインスタンスを渡します。コンストラクタであるため、特定の戻り値はありません。新しいWeakReferenceインスタンスを初期化し、指定されたオブジェクトへの弱い参照を保持するよう設定します。

サンプルコードでは、WeakReferenceContainer::create()メソッド内でnew WeakReference($objectToRefer)として呼び出され、$objectToReferへの弱い参照が作成されています。作成された弱い参照は、get()メソッドを通じて参照先のオブジェクトを取得できますが、元のオブジェクトへの強参照が全て解除され、ガベージコレクションが実行されると、get()はnullを返すようになります。

また、サンプルコードのWeakReferenceContainerクラスのコンストラクタでは、PHP 8で追加された「コンストラクタプロパティプロモーション」が利用されており、プロパティの定義と初期化を同時に行うことでコードを簡潔にしています。このWeakReferenceを活用することで、キャッシュの実装や循環参照の回避など、メモリ管理の高度な制御が必要な場面でリソースを効率的に利用する設計が可能になります。

Copy
1<?php
2
3// 弱い参照が指すことができるクラスを定義します。
4// このクラスは、インスタンスが作成・破棄されたときにメッセージを表示します。
5class User
6{
7    public string $name;
8
9    public function __construct(string $name)
10    {
11        $this->name = $name;
12        echo "ユーザー '{$this->name}' が作成されました。\n";
13    }
14
15    public function __destruct()
16    {
17        echo "ユーザー '{$this->name}' が破棄されました。\n";
18    }
19}
20
21// 1. 参照されるオブジェクト（強い参照）を作成します。
22$user = new User("Alice");
23
24// 2. WeakReferenceのコンストラクタ(__construct) を使用して、
25//    $userオブジェクトへの弱い参照を作成します。
26//    $weakRef = new WeakReference($object) の形式で呼び出されます。
27//    この参照は$userオブジェクトの参照カウントを増やしません。
28$weakRef = new WeakReference($user);
29
30echo "\n--- 最初の状態 ---\n";
31// 弱い参照がまだオブジェクトを指しているか確認します。
32// get()メソッドは、オブジェクトが生きていればそのオブジェクトを、そうでなければnullを返します。
33if ($weakRef->get()) {
34    echo "弱い参照は現在、ユーザー: " . $weakRef->get()->name . " を指しています。\n";
35} else {
36    echo "弱い参照はオブジェクトを指していません。\n";
37}
38
39// 3. 元のオブジェクトへの強い参照を解除します。
40//    $userオブジェクトへの強い参照がすべてなくなると、PHPのガベージコレクタによって
41//    オブジェクトがメモリから解放される対象となります。
42unset($user);
43echo "元の強い参照が解除されました。\n";
44
45// 通常、ガベージコレクションはPHPが自動的に行いますが、
46// テスト目的で明示的にサイクルガベージコレクタを実行します。
47// (実際のアプリケーションでは、ほとんどの場合、明示的な呼び出しは不要です)
48gc_collect_cycles();
49
50echo "\n--- 強い参照解除後 ---\n";
51// 強い参照が解除され、オブジェクトが破棄された後、
52// 弱い参照がまだオブジェクトを指しているか確認します。
53// オブジェクトが破棄されていれば、$weakRef->get() は null を返します。
54if ($weakRef->get()) {
55    echo "弱い参照はまだオブジェクト: " . $weakRef->get()->name . " を指しています。\n";
56} else {
57    echo "弱い参照はオブジェクトを指していません。（オブジェクトが破棄されました）\n";
58}
59
60?>

PHPのWeakReference::__constructは、指定されたオブジェクトへの「弱い参照」を作成するためのコンストラクタです。通常の変数によるオブジェクト参照が「強い参照」と呼ばれ、オブジェクトがメモリから解放されないように参照カウントを増やすのに対し、「弱い参照」はオブジェクトの参照カウントを増やしません。これにより、弱い参照が存在してもオブジェクトの寿命には影響を与えないという特徴があります。

このコンストラクタにはobject $objectという引数が必要で、これは弱い参照の対象としたいオブジェクトそのものです。戻り値は特にありません。

サンプルコードでは、Userクラスのインスタンスをまず「強い参照」として作成し、次にWeakReference::__constructを用いてそのUserオブジェクトへの「弱い参照」を作ります。その後、元の「強い参照」を解除すると、オブジェクトはガベージコレクションの対象となり破棄されます。すると、それまで有効だった「弱い参照」も自動的に無効となり、get()メソッドでオブジェクトを取得しようとするとnullが返されることが確認できます。これは、メモリ管理においてオブジェクトの寿命を制御しながら、必要に応じて一時的にオブジェクトを参照したい場合に役立つ機能です。

Copy
1<?php
2
3// 親クラスの定義
4// このクラスは、コンストラクタで名前を受け取り、プロパティに設定します。
5class BaseService
6{
7    protected string $serviceName;
8
9    /**
10     * BaseService のコンストラクタ。
11     *
12     * @param string $name このサービスの識別名
13     */
14    public function __construct(string $name)
15    {
16        $this->serviceName = $name;
17        echo "BaseService: '{$this->serviceName}' 初期化完了。\n";
18    }
19
20    /**
21     * サービス名を取得します。
22     *
23     * @return string サービス名
24     */
25    public function getServiceName(): string
26    {
27        return $this->serviceName;
28    }
29}
30
31// サービスを管理するクラスの定義
32// このクラスは BaseService を継承し、さらに WeakReference を使って他のオブジェクトへの
33// 「弱い参照」を保持します。
34class ServiceManager extends BaseService
35{
36    // 弱く参照されるオブジェクトを保持するためのプロパティ
37    private ?WeakReference $managedObjectRef = null;
38
39    /**
40     * ServiceManager のコンストラクタ。
41     * 親クラスのコンストラクタを呼び出し、指定されたオブジェクトへの弱い参照を作成します。
42     *
43     * @param string $managerName このマネージャーの名前
44     * @param object $objectToManage 弱く参照したいオブジェクト
45     */
46    public function __construct(string $managerName, object $objectToManage)
47    {
48        // キーワード「parent」に関連: 親クラス (BaseService) のコンストラクタを呼び出す
49        // これにより、親クラスの初期化ロジックが実行され、共通のプロパティが設定されます。
50        parent::__construct($managerName);
51        echo "ServiceManager: '{$this->serviceName}' 初期化開始。\n";
52
53        // WeakReference::__construct の使用例:
54        // WeakReference::create() メソッドは、PHPの内部で WeakReference の __construct メソッドを呼び出し、
55        // 指定されたオブジェクト ($objectToManage) への弱い参照を作成します。
56        // この弱い参照は、$objectToManage が他のどこからも強く参照されなくなった場合、
57        // ガベージコレクションによって解放されることを妨げません。
58        $this->managedObjectRef = WeakReference::create($objectToManage);
59        echo "ServiceManager: オブジェクトへの弱い参照を作成しました。\n";
60    }
61
62    /**
63     * 弱く参照されているオブジェクトを取得します。
64     * オブジェクトがすでにガベージコレクションによって解放されている場合は null を返します。
65     *
66     * @return object|null 弱く参照されているオブジェクト、または null
67     */
68    public function getManagedObject(): ?object
69    {
70        return $this->managedObjectRef?->get();
71    }
72}
73
74// 弱く参照される側のサンプルオブジェクト
75class DataObject
76{
77    public string $id;
78
79    /**
80     * DataObject のコンストラクタ。
81     *
82     * @param string $id このデータオブジェクトのID
83     */
84    public function __construct(string $id)
85    {
86        $this->id = $id;
87        echo "DataObject (ID: {$this->id}) 作成。\n";
88    }
89
90    /**
91     * DataObject が破棄されるときに呼び出されるマジックメソッド。
92     * ガベージコレクションによってオブジェクトが解放されたことを確認するために使用します。
93     */
94    public function __destruct()
95    {
96        echo "DataObject (ID: {$this->id}) 破棄。\n";
97    }
98}
99
100// --- サンプルコードの実行 ---
101
102// 1. 弱く参照されるDataObjectのインスタンスを作成（$dataが強い参照）
103echo "--- 実行開始 ---\n\n";
104$data = new DataObject("ABC-123");
105
106// 2. ServiceManager のインスタンスを作成し、DataObject への弱い参照を持たせる
107// ここで ServiceManager のコンストラクタが呼び出され、親クラスのコンストラクタも実行されます。
108echo "\n--- ServiceManager の作成 ---\n";
109$manager = new ServiceManager("MainManager", $data);
110
111// 3. ServiceManager から弱く参照されているオブジェクトを取得し、その状態を確認
112echo "\n--- 弱い参照の確認 (初期状態) ---\n";
113if ($obj = $manager->getManagedObject()) {
114    echo "ServiceManager が参照しているオブジェクトのID: " . $obj->id . " (存在)\n";
115} else {
116    echo "ServiceManager が参照しているオブジェクトは null です。\n";
117}
118
119// 4. 元の強い参照 ($data) を解除する
120echo "\n--- 元の強い参照を解除 (unset(\$data)) ---\n";
121unset($data);
122echo "強い参照 (\$data) が解除されました。\n";
123
124// 5. 強い参照解除後に ServiceManager から弱く参照されているオブジェクトを再度取得し、状態を確認
125// 通常、この時点でDataObjectはガベージコレクションによって破棄されています。
126echo "\n--- 弱い参照の確認 (強い参照解除後) ---\n";
127if ($obj = $manager->getManagedObject()) {
128    echo "ServiceManager が参照しているオブジェクトのID: " . $obj->id . " (まだ存在)\n";
129} else {
130    echo "ServiceManager が参照しているオブジェクトは null です (破棄済み)。\n";
131}
132
133// 6. ServiceManager 自体を破棄すると、それに含まれる WeakReference インスタンスも解放されます。
134echo "\n--- ServiceManager の破棄 ---\n";
135unset($manager);
136echo "--- 実行終了 ---\n";
137
138?>

このサンプルコードは、PHPにおけるオブジェクト指向プログラミングの「継承」と「弱い参照（WeakReference）」という二つの重要な概念を組み合わせて示しています。

まず、BaseServiceクラスは、コンストラクタ__constructで名前を受け取り、自身のプロパティを初期化します。ServiceManagerクラスはBaseServiceを継承しており、そのコンストラクタ__construct内で、parent::__construct($managerName)という記述を使って親クラスBaseServiceのコンストラクタを呼び出しています。これは、継承されたクラスが親クラスの初期化ロジックを実行するために利用される一般的な方法です。

その後、ServiceManagerのコンストラクタはWeakReference::create($objectToManage)を呼び出しています。このメソッドが内部的にWeakReference::__constructを利用し、引数として渡された$objectToManageへの「弱い参照」を作成します。WeakReference::__construct自体は戻り値を持ちません。弱い参照とは、そのオブジェクトが他のどこからも強く参照されていない場合に、PHPのガベージコレクションによって自動的にメモリから解放されることを妨げない参照のことです。通常の参照がオブジェクトの生存期間を保証するのに対し、弱い参照はそうではありません。

サンプルコードの実行部分では、まずDataObjectを強く参照する変数を作成します。次に、ServiceManagerがそのDataObjectへの弱い参照を持ちます。その後、DataObjectへの強い参照を解除すると、DataObjectはメモリから解放されるため、ServiceManagerが持つ弱い参照からはそのオブジェクトを取得できなくなることが確認できます。これにより、特定のオブジェクトが不要になった際に、他の弱い参照がそのオブジェクトのメモリ解放を阻害しないという挙動を理解することができます。

Copy
1<?php
2
3// このクラスは、弱参照で監視される対象オブジェクトの例です。
4// オブジェクトの生成と破棄のタイミングを分かりやすくするため、
5// コンストラクタとデストラクタでメッセージを出力します。
6class MyMonitorableObject
7{
8    public string $id;
9
10    public function __construct(string $id)
11    {
12        $this->id = $id;
13        echo "MyMonitorableObject (ID: {$this->id}) が作成されました。\n";
14    }
15
16    public function __destruct()
17    {
18        echo "MyMonitorableObject (ID: {$this->id}) が破棄されました。\n";
19    }
20}
21
22echo "--- 弱参照の作成と利用の開始 ---\n\n";
23
24// 1. 監視対象となる通常のオブジェクトを作成します。
25$someObject = new MyMonitorableObject("ObjectA");
26
27// 2. WeakReference::__construct を使用して、このオブジェクトへの弱参照を作成します。
28//    引数には、監視したいオブジェクト ($someObject) を渡します。
29//    弱参照は、元のオブジェクトの参照カウントを増やさないため、
30//    元のオブジェクトがどこからも参照されなくなると、ガベージコレクションの対象となります。
31$weakRef = new WeakReference($someObject);
32
33echo "\n--- 弱参照がオブジェクトを参照していることを確認 ---\n";
34
35// 3. 弱参照から元のオブジェクトを取得しようとします。
36//    $someObject がまだ存在するため、弱参照は MyMonitorableObject のインスタンスを返します。
37$retrievedObject = $weakRef->get();
38
39if ($retrievedObject instanceof MyMonitorableObject) {
40    echo "弱参照は '{$retrievedObject->id}' を参照しています。\n";
41} else {
42    echo "エラー: 弱参照がオブジェクトを参照していません。\n";
43}
44
45echo "\n--- 元のオブジェクトへの参照を解除 ---\n";
46
47// 4. 元のオブジェクト ($someObject) への参照を解除します。
48//    これにより、$someObject がどこからも参照されなくなり、
49//    MyMonitorableObject のデストラクタが呼び出され、オブジェクトが破棄されます。
50$someObject = null;
51
52echo "\n--- 元のオブジェクトが破棄された後の弱参照の状態を確認 ---\n";
53
54// 5. 元のオブジェクトが破棄された後、再度弱参照からオブジェクトを取得しようとします。
55//    弱参照は元のオブジェクトがガベージコレクションによって破棄されたことを検知し、
56//    null を返します。
57$retrievedObjectAfterDestruction = $weakRef->get();
58
59if ($retrievedObjectAfterDestruction === null) {
60    echo "弱参照は元のオブジェクトが破棄されたため、現在は何も参照していません (null を返しました)。\n";
61} else {
62    echo "エラー: 弱参照がまだオブジェクトを参照しています（予期しない動作）。\n";
63}
64
65echo "\n--- 弱参照の利用終了 ---\n";
66
67?>

WeakReference::__construct メソッドは、PHP 8で導入された「弱参照」を生成するために使用されます。このコンストラクタは引数として object $object を一つ取り、指定されたオブジェクトへの弱参照を作成しますが、戻り値はありません。

弱参照とは、通常のオブジェクト参照と異なり、参照先のオブジェクトがメモリから解放されるのを妨げない特殊な参照です。つまり、弱参照だけが残っているオブジェクトは、ガベージコレクションの対象となり、自動的にメモリが解放されます。これは、弱参照がオブジェクトの参照カウントを増やさないためです。

サンプルコードでは、まず MyMonitorableObject という補助的なクラスのインスタンスを生成し、そのオブジェクトを new WeakReference($someObject) の引数として渡すことで弱参照を作成しています。弱参照が作成された後でも、元のオブジェクトへの参照が解除されれば、MyMonitorableObject のデストラクタが呼び出され、オブジェクトが正常に破棄される様子が確認できます。

WeakReference インスタンスが持つ get() メソッドは、弱参照が監視しているオブジェクトがまだ存在していればそのオブジェクトを返し、既に破棄されている場合は null を返します。これにより、オブジェクトのライフサイクルを監視しながら、メモリ管理に影響を与えない参照を安全に扱えるようになります。