1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
//! 可共享的可变容器。
//!
//! Rust 内存安全基于以下规则:给定一个对象 `T`,它只能具有以下之一:
//!
//! - 对对象具有多个不可变引用 (`&T`) (也称为别名)。
//! - 对对象有一个可变引用 (`&mut T`) (也称为可变性)。
//!
//! 这由 Rust 编译器强制执行。但是,在某些情况下,此规则不够灵活。有时需要对一个对象进行多次引用,然后对其进行可变的。
//!
//! 存在共享的可变容器以允许以受控的方式进行可变性,即使在出现混叠的情况下也是如此。
//! [`Cell<T>`]、[`RefCell<T>`] 和 [`OnceCell<T>`] 允许以单线程方式实现这一点,但它们不实现 [`Sync`]。
//! (如果您需要在多个线程之间进行别名和可变的,[`Mutex<T>`]、[`RwLock<T>`]、[`OnceLock<T>`] 或 [`atomic`] 类型是执行此操作的正确数据结构)。
//!
//! `Cell<T>`、`RefCell<T>` 和 `OnceCell<T>` 类型的值可以通过共享引用 (即常见的 `&T` 类型) 进行可变,而大多数 Rust 类型只能通过唯一的 (`&mut T`) 引用进行可变。
//! 我们说这些 cell 类型提供 `内部可变性` (通过 `&T` 可变),与表现出 `继承可变性` (仅通过 `&mut T` 可变) 的典型 Rust 类型形成对比。
//!
//! Cell 类型分为三种类型: `Cell<T>`、`RefCell<T>` 和 `OnceCell<T>`。每个都提供了一种不同的方式来提供安全的内部可变性。
//!
//! ## `Cell<T>`
//!
//! [`Cell<T>`] 通过将值移入和移出 cell 来实现内部可变性。
//! 也就是说,永远无法获取到内部值的 `&mut T`,如果不将其替换为其他内容,则无法直接获取值本身。
//! 这两条规则都确保永远不会有一个以上的引用指向内部值。
//! 该类型提供了以下方法:
//!
//!  - 对于实现 [`Copy`] 的类型,[`get`](Cell::get) 方法通过复制它来检索当前内部值。
//!  - 对于实现 [`Default`] 的类型,[`take`](Cell::take) 方法将当前内部值替换为 [`Default::default()`],然后返回替换后的值。
//!  - 所有类型都有:
//!    - [`replace`](Cell::replace): 替换当前内部值并返回替换后的值。
//!    - [`into_inner`](Cell::into_inner): 此方法使用 `Cell<T>` 并返回内部值。
//!    - [`set`](Cell::set): 该方法替换内部值,丢弃替换后的值。
//!
//! `Cell<T>` 通常用于更简单的类型,在这些类型中复制或移动值不会占用太多资源 (例如数字),并且在可能的情况下通常应优先于其他 cell 类型。
//! 对于较大的非复制类型,`RefCell` 提供了一些优势。
//!
//! ## `RefCell<T>`
//!
//! [`RefCell<T>`] 使用 Rust 的生命周期来实现 "dynamic borrowing",这是一个可以临时、独占、可更改访问内部值的过程。
//! `RefCell<T>`s 的引用在运行时被跟踪,这与 Rust 的原生引用类型不同,后者在编译时完全静态地被跟踪。
//!
//! 可以使用 [`borrow`](`RefCell::borrow`) 获取对 `RefCell` 的内部值 (`&T`) 的不可更改引用,使用 [`borrow_mut`](`RefCell::borrow_mut`) 可以获取不可更改引用 (`&mut T`)。
//! 当调用这些函数时,它们首先验证是否满足 Rust 的借用规则: 允许任意数量的不可改变借用或允许单个不可改变借用,但绝不能同时使用。
//! 如果尝试违反这些规则的借用,线程将崩溃。
//!
//! `RefCell<T>` 对应的 [`Sync`] 版本为 [`RwLock<T>`]。
//!
//! ## `OnceCell<T>`
//!
//! [`OnceCell<T>`] 在某种程度上是 `Cell` 和 `RefCell` 的混合体,适用于通常只需要设置一次的值。
//! 这意味着无需移动或复制内部值 (与 `Cell` 不同) 也无需运行时检查 (与 `RefCell` 不同) 即可获得引用 `&T`。
//! 然而,它的值一旦设置也不能更新,除非您有一个可变引用到 `OnceCell`。
//!
//! `OnceCell` 提供了以下方法:
//!
//! - [`get`](OnceCell::get): 获取对内部值的引用
//! - [`set`](OnceCell::set): 如果未设置则设置内部值 (返回 `Result`)
//! - [`get_or_init`](OnceCell::get_or_init): 返回内部值,如果需要则初始化它
//! - [`get_mut`](OnceCell::get_mut): 提供对内部值的可变引用,仅当您对 cell 本身具有可变引用时才可用。
//!
//! `OnceCell<T>` 对应的 [`Sync`] 版本为 [`OnceLock<T>`]。
//!
//! # 何时选择内部可变性
//!
//! 更常见的继承的可变性 (其中必须具有对值的唯一访问权) 是使 Rust 能够强烈考虑指针别名的关键语言元素之一,从而可以静态地防止崩溃错误。
//! 因此,首选继承的可变性,而内部可变性则是不得已而为之。
//! 由于 cell 类型能够在不允许的情况下实现可变,所以有时内部可变性可能是合适的,或者甚至必须使用,例如
//!
//! * 在不可变的内部引入可变性
//! * 逻辑上不可变的方法的实现细节。
//! * [`Clone`] 的变异实现。
//!
//! ## 在不可变的内部引入可变性
//!
//! 许多共享的智能指针类型,包括 [`Rc<T>`] 和 [`Arc<T>`],都提供了可以在多方之间克隆和共享的容器。
//! 由于所包含的值可能具有多重别名,因此只能使用 `&`,而不能使用 `&mut` 来借用它们。
//! 如果没有 cell,根本不可能改变这些智能指针内的数据。
//!
//! 然后,在共享指针类型中放置一个 `RefCell<T>` 来重新引入可变性是非常常见的:
//!
//! ```
//! use std::cell::{RefCell, RefMut};
//! use std::collections::HashMap;
//! use std::rc::Rc;
//!
//! fn main() {
//!     let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));
//!     // 创建一个新块以限制动态借用的作用域
//!     {
//!         let mut map: RefMut<'_, _> = shared_map.borrow_mut();
//!         map.insert("africa", 92388);
//!         map.insert("kyoto", 11837);
//!         map.insert("piccadilly", 11826);
//!         map.insert("marbles", 38);
//!     }
//!
//!     // 请注意,如果我们没有让缓存的上一次借用离开作用域,那么后续的借用将导致动态线程 panic。
//!     //
//!     // 这是使用 `RefCell` 的主要危险。
//!     let total: i32 = shared_map.borrow().values().sum();
//!     println!("{total}");
//! }
//! ```
//!
//! 请注意,这个例子使用了 `Rc<T>` 而不是 `Arc<T>`。`RefCell<T>`s 适用于单线程场景。如果在多线程情况下需要共享可变性,可以考虑使用 [`RwLock<T>`] 或 [`Mutex<T>`]。
//!
//! ## 逻辑上的不可变方法的实现细节
//!
//! 有时,可能希望不要在 API 中公开幕后发生了变异。
//! 这可能是因为逻辑上该操作是不可变的,但是例如,缓存会强制实现执行变异; 或者是因为您必须使用突变来实现一个最初定义为接受 `&self` 的 trait 方法。
//!
//!
//! ```
//! # #![allow(dead_code)]
//! use std::cell::RefCell;
//!
//! struct Graph {
//!     edges: Vec<(i32, i32)>,
//!     span_tree_cache: RefCell<Option<Vec<(i32, i32)>>>
//! }
//!
//! impl Graph {
//!     fn minimum_spanning_tree(&self) -> Vec<(i32, i32)> {
//!         self.span_tree_cache.borrow_mut()
//!             .get_or_insert_with(|| self.calc_span_tree())
//!             .clone()
//!     }
//!
//!     fn calc_span_tree(&self) -> Vec<(i32, i32)> {
//!         // 昂贵的计算在这里
//!         vec![]
//!     }
//! }
//! ```
//!
//! ## `Clone` 的变异实现
//!
//! 这只是一种特殊情况 - 但很常见 - 以前的情况:隐藏看起来不可变的操作的可变性。
//! [`clone`](Clone::clone) 方法不会更改源值,并声明采用 `&self`,而不是 `&mut self`。
//! 因此,在 `clone` 方法中发生的任何变异的都必须使用 cell 类型。
//! 例如,[`Rc<T>`] 在 `Cell<T>` 中维护它的引用计数。
//!
//! ```
//! use std::cell::Cell;
//! use std::ptr::NonNull;
//! use std::process::abort;
//! use std::marker::PhantomData;
//!
//! struct Rc<T: ?Sized> {
//!     ptr: NonNull<RcBox<T>>,
//!     phantom: PhantomData<RcBox<T>>,
//! }
//!
//! struct RcBox<T: ?Sized> {
//!     strong: Cell<usize>,
//!     refcount: Cell<usize>,
//!     value: T,
//! }
//!
//! impl<T: ?Sized> Clone for Rc<T> {
//!     fn clone(&self) -> Rc<T> {
//!         self.inc_strong();
//!         Rc {
//!             ptr: self.ptr,
//!             phantom: PhantomData,
//!         }
//!     }
//! }
//!
//! trait RcBoxPtr<T: ?Sized> {
//!
//!     fn inner(&self) -> &RcBox<T>;
//!
//!     fn strong(&self) -> usize {
//!         self.inner().strong.get()
//!     }
//!
//!     fn inc_strong(&self) {
//!         self.inner()
//!             .strong
//!             .set(self.strong()
//!                      .checked_add(1)
//!                      .unwrap_or_else(|| abort() ));
//!     }
//! }
//!
//! impl<T: ?Sized> RcBoxPtr<T> for Rc<T> {
//!    fn inner(&self) -> &RcBox<T> {
//!        unsafe {
//!            self.ptr.as_ref()
//!        }
//!    }
//! }
//! ```
//!
//! [`Arc<T>`]: ../../std/sync/struct.Arc.html
//! [`Rc<T>`]: ../../std/rc/struct.Rc.html
//! [`RwLock<T>`]: ../../std/sync/struct.RwLock.html
//! [`Mutex<T>`]: ../../std/sync/struct.Mutex.html
//! [`OnceLock<T>`]: ../../std/sync/struct.OnceLock.html
//! [`Sync`]: ../../std/marker/trait.Sync.html
//! [`atomic`]: crate::sync::atomic
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!

#![stable(feature = "rust1", since = "1.0.0")]

use crate::cmp::Ordering;
use crate::fmt::{self, Debug, Display};
use crate::marker::{PhantomData, Unsize};
use crate::mem;
use crate::ops::{CoerceUnsized, Deref, DerefMut, DispatchFromDyn};
use crate::ptr::{self, NonNull};

mod lazy;
mod once;

#[unstable(feature = "lazy_cell", issue = "109736")]
pub use lazy::LazyCell;
#[stable(feature = "once_cell", since = "1.70.0")]
pub use once::OnceCell;

/// 可变的内存位置。
///
/// # 内存布局
///
/// `Cell<T>` 具有与 `UnsafeCell<T>`](UnsafeCell#memory-layout) 相同的 [内存布局和注意事项。
/// 特别是,这意味着 `Cell<T>` 与其内部类型 `T` 具有相同的内存表示。
///
///
/// # Examples
///
/// 在这个例子中,您可以看到 `Cell<T>` 在一个不可变的结构中实现了变异。
/// 换句话说,它实现了内部可变性。
///
/// ```
/// use std::cell::Cell;
///
/// struct SomeStruct {
///     regular_field: u8,
///     special_field: Cell<u8>,
/// }
///
/// let my_struct = SomeStruct {
///     regular_field: 0,
///     special_field: Cell::new(1),
/// };
///
/// let new_value = 100;
///
/// // ERROR: `my_struct` 是不可变 my_struct.regular_field =new_value;
/////
///
/// // WORKS: 尽管 `my_struct` 是不可变的,但是 `special_field` 是 `Cell`,可以随时对其进行修改
/////
/// my_struct.special_field.set(new_value);
/// assert_eq!(my_struct.special_field.get(), new_value);
/// ```
///
/// 有关更多信息,请参见 [模块级文档](self)。
#[stable(feature = "rust1", since = "1.0.0")]
#[repr(transparent)]
pub struct Cell<T: ?Sized> {
    value: UnsafeCell<T>,
}

#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized> Send for Cell<T> where T: Send {}

// 请注意,这个 negative impl 对于正确性来说并不是严格必要的,因为 `Cell` 包装了 `UnsafeCell`,而 `UnsafeCell` 本身就是 `!Sync`。
// 然而,考虑到 `Cell` 的 `!Sync` 特性是多么重要,有一个显式的 negative impl 对于文档来说是很好的,并且会产生更好的错误消息。
//
//
//
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !Sync for Cell<T> {}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Copy> Clone for Cell<T> {
    #[inline]
    fn clone(&self) -> Cell<T> {
        Cell::new(self.get())
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Default> Default for Cell<T> {
    /// 创建一个 `Cell<T>`,使用 T 的 `Default` 值。
    #[inline]
    fn default() -> Cell<T> {
        Cell::new(Default::default())
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: PartialEq + Copy> PartialEq for Cell<T> {
    #[inline]
    fn eq(&self, other: &Cell<T>) -> bool {
        self.get() == other.get()
    }
}

#[stable(feature = "cell_eq", since = "1.2.0")]
impl<T: Eq + Copy> Eq for Cell<T> {}

#[stable(feature = "cell_ord", since = "1.10.0")]
impl<T: PartialOrd + Copy> PartialOrd for Cell<T> {
    #[inline]
    fn partial_cmp(&self, other: &Cell<T>) -> Option<Ordering> {
        self.get().partial_cmp(&other.get())
    }

    #[inline]
    fn lt(&self, other: &Cell<T>) -> bool {
        self.get() < other.get()
    }

    #[inline]
    fn le(&self, other: &Cell<T>) -> bool {
        self.get() <= other.get()
    }

    #[inline]
    fn gt(&self, other: &Cell<T>) -> bool {
        self.get() > other.get()
    }

    #[inline]
    fn ge(&self, other: &Cell<T>) -> bool {
        self.get() >= other.get()
    }
}

#[stable(feature = "cell_ord", since = "1.10.0")]
impl<T: Ord + Copy> Ord for Cell<T> {
    #[inline]
    fn cmp(&self, other: &Cell<T>) -> Ordering {
        self.get().cmp(&other.get())
    }
}

#[stable(feature = "cell_from", since = "1.12.0")]
impl<T> From<T> for Cell<T> {
    /// 创建一个包含给定值的新 `Cell<T>`。
    fn from(t: T) -> Cell<T> {
        Cell::new(t)
    }
}

impl<T> Cell<T> {
    /// 创建一个包含给定值的新 `Cell`。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let c = Cell::new(5);
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_stable(feature = "const_cell_new", since = "1.24.0")]
    #[inline]
    pub const fn new(value: T) -> Cell<T> {
        Cell { value: UnsafeCell::new(value) }
    }

    /// 设置包含的值。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let c = Cell::new(5);
    ///
    /// c.set(10);
    /// ```
    #[inline]
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn set(&self, val: T) {
        let old = self.replace(val);
        drop(old);
    }

    /// 交换两个 `Cell` 的值。
    /// 与 `std::mem::swap` 的区别在于,这个函数不需要 `&mut` 引用。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let c1 = Cell::new(5i32);
    /// let c2 = Cell::new(10i32);
    /// c1.swap(&c2);
    /// assert_eq!(10, c1.get());
    /// assert_eq!(5, c2.get());
    /// ```
    #[inline]
    #[stable(feature = "move_cell", since = "1.17.0")]
    pub fn swap(&self, other: &Self) {
        if ptr::eq(self, other) {
            return;
        }
        // SAFETY: 如果从单独的线程中调用,可能会有风险,但是 `Cell` 是 `!Sync`,所以这不会发生。
        // 这也不会使任何指针无效,因为 `Cell` 确保没有其他指针指向这些 `Cell` 中的任何一个。
        //
        //
        unsafe {
            ptr::swap(self.value.get(), other.value.get());
        }
    }

    /// 用 `val` 替换包含的值,并返回旧的包含的值。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let cell = Cell::new(5);
    /// assert_eq!(cell.get(), 5);
    /// assert_eq!(cell.replace(10), 5);
    /// assert_eq!(cell.get(), 10);
    /// ```
    #[inline]
    #[stable(feature = "move_cell", since = "1.17.0")]
    pub fn replace(&self, val: T) -> T {
        // SAFETY: 如果从单独的线程中调用,则可能导致数据竞争,但是 `Cell` 是 `!Sync`,因此不会发生。
        //
        mem::replace(unsafe { &mut *self.value.get() }, val)
    }

    /// 解开值,消耗 cell。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let c = Cell::new(5);
    /// let five = c.into_inner();
    ///
    /// assert_eq!(five, 5);
    /// ```
    #[stable(feature = "move_cell", since = "1.17.0")]
    #[rustc_const_unstable(feature = "const_cell_into_inner", issue = "78729")]
    pub const fn into_inner(self) -> T {
        self.value.into_inner()
    }
}

impl<T: Copy> Cell<T> {
    /// 返回所包含值的副本。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let c = Cell::new(5);
    ///
    /// let five = c.get();
    /// ```
    #[inline]
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn get(&self) -> T {
        // SAFETY: 如果从单独的线程中调用,则可能导致数据竞争,但是 `Cell` 是 `!Sync`,因此不会发生。
        //
        unsafe { *self.value.get() }
    }

    /// 使用函数更新包含的值并返回新值。
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(cell_update)]
    ///
    /// use std::cell::Cell;
    ///
    /// let c = Cell::new(5);
    /// let new = c.update(|x| x + 1);
    ///
    /// assert_eq!(new, 6);
    /// assert_eq!(c.get(), 6);
    /// ```
    #[inline]
    #[unstable(feature = "cell_update", issue = "50186")]
    pub fn update<F>(&self, f: F) -> T
    where
        F: FnOnce(T) -> T,
    {
        let old = self.get();
        let new = f(old);
        self.set(new);
        new
    }
}

impl<T: ?Sized> Cell<T> {
    /// 返回指向此 cell 中底层数据的裸指针。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let c = Cell::new(5);
    ///
    /// let ptr = c.as_ptr();
    /// ```
    #[inline]
    #[stable(feature = "cell_as_ptr", since = "1.12.0")]
    #[rustc_const_stable(feature = "const_cell_as_ptr", since = "1.32.0")]
    pub const fn as_ptr(&self) -> *mut T {
        self.value.get()
    }

    /// 返回对底层数据的可变引用。
    ///
    /// 这个调用可变地 (在编译时) 借用了 `Cell`,这保证了我们拥有唯一的引用。
    ///
    /// 但是要小心:此方法要求 `self` 是可变的,而使用 `Cell` 时通常不是这种情况。
    /// 如果您需要通过引用实现内部可变性,可以考虑使用 `RefCell`,它通过其 [`borrow_mut`] 方法提供运行时检查的可变借用。
    ///
    ///
    /// [`borrow_mut`]: RefCell::borrow_mut()
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let mut c = Cell::new(5);
    /// *c.get_mut() += 1;
    ///
    /// assert_eq!(c.get(), 6);
    /// ```
    ///
    ///
    #[inline]
    #[stable(feature = "cell_get_mut", since = "1.11.0")]
    pub fn get_mut(&mut self) -> &mut T {
        self.value.get_mut()
    }

    /// 从 `&mut T` 返回 `&Cell<T>`
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let slice: &mut [i32] = &mut [1, 2, 3];
    /// let cell_slice: &Cell<[i32]> = Cell::from_mut(slice);
    /// let slice_cell: &[Cell<i32>] = cell_slice.as_slice_of_cells();
    ///
    /// assert_eq!(slice_cell.len(), 3);
    /// ```
    #[inline]
    #[stable(feature = "as_cell", since = "1.37.0")]
    pub fn from_mut(t: &mut T) -> &Cell<T> {
        // SAFETY: `&mut` 确保访问的唯一性。
        unsafe { &*(t as *mut T as *const Cell<T>) }
    }
}

impl<T: Default> Cell<T> {
    /// 获取 cell 的值,将 `Default::default()` 保留在其位置。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let c = Cell::new(5);
    /// let five = c.take();
    ///
    /// assert_eq!(five, 5);
    /// assert_eq!(c.into_inner(), 0);
    /// ```
    #[stable(feature = "move_cell", since = "1.17.0")]
    pub fn take(&self) -> T {
        self.replace(Default::default())
    }
}

#[unstable(feature = "coerce_unsized", issue = "18598")]
impl<T: CoerceUnsized<U>, U> CoerceUnsized<Cell<U>> for Cell<T> {}

// 允许包装 `Cell` 的类型也实现 `DispatchFromDyn` 并成为对象安全方法接收器。
//
// 请注意,目前 `Cell` 本身不能是方法接管者,因为它没有实现 Deref。
// 换句话说:
// `self: Cell<&Self>` 行不通 `self: CellWrapper<Self>` 成为可能
//
//
#[unstable(feature = "dispatch_from_dyn", issue = "none")]
impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<Cell<U>> for Cell<T> {}

impl<T> Cell<[T]> {
    /// 从 `&Cell<[T]>` 返回 `&[Cell<T>]`
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::Cell;
    ///
    /// let slice: &mut [i32] = &mut [1, 2, 3];
    /// let cell_slice: &Cell<[i32]> = Cell::from_mut(slice);
    /// let slice_cell: &[Cell<i32>] = cell_slice.as_slice_of_cells();
    ///
    /// assert_eq!(slice_cell.len(), 3);
    /// ```
    #[stable(feature = "as_cell", since = "1.37.0")]
    pub fn as_slice_of_cells(&self) -> &[Cell<T>] {
        // SAFETY: `Cell<T>` 具有与 `T` 相同的内存布局。
        unsafe { &*(self as *const Cell<[T]> as *const [Cell<T>]) }
    }
}

impl<T, const N: usize> Cell<[T; N]> {
    /// 从 `&Cell<[T; N]>` 返回 `&[Cell<T>; N]`
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(as_array_of_cells)]
    /// use std::cell::Cell;
    ///
    /// let mut array: [i32; 3] = [1, 2, 3];
    /// let cell_array: &Cell<[i32; 3]> = Cell::from_mut(&mut array);
    /// let array_cell: &[Cell<i32>; 3] = cell_array.as_array_of_cells();
    /// ```
    #[unstable(feature = "as_array_of_cells", issue = "88248")]
    pub fn as_array_of_cells(&self) -> &[Cell<T>; N] {
        // SAFETY: `Cell<T>` 具有与 `T` 相同的内存布局。
        unsafe { &*(self as *const Cell<[T; N]> as *const [Cell<T>; N]) }
    }
}

/// 具有动态检查借用规则的可变内存位置
///
/// 有关更多信息,请参见 [模块级文档](self)。
#[cfg_attr(not(test), rustc_diagnostic_item = "RefCell")]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct RefCell<T: ?Sized> {
    borrow: Cell<BorrowFlag>,
    // 存储当前最早活跃的的借用的位置。
    // 每当我们从零借用变为单一借用时,这个就会更新。
    // 当发生借用时,这将包含在生成的 `BorrowError`/`BorrowMutError` 中
    //
    #[cfg(feature = "debug_refcell")]
    borrowed_at: Cell<Option<&'static crate::panic::Location<'static>>>,
    value: UnsafeCell<T>,
}

/// [`RefCell::try_borrow`] 返回的错误。
#[stable(feature = "try_borrow", since = "1.13.0")]
#[non_exhaustive]
pub struct BorrowError {
    #[cfg(feature = "debug_refcell")]
    location: &'static crate::panic::Location<'static>,
}

#[stable(feature = "try_borrow", since = "1.13.0")]
impl Debug for BorrowError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut builder = f.debug_struct("BorrowError");

        #[cfg(feature = "debug_refcell")]
        builder.field("location", self.location);

        builder.finish()
    }
}

#[stable(feature = "try_borrow", since = "1.13.0")]
impl Display for BorrowError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Display::fmt("already mutably borrowed", f)
    }
}

/// [`RefCell::try_borrow_mut`] 返回的错误。
#[stable(feature = "try_borrow", since = "1.13.0")]
#[non_exhaustive]
pub struct BorrowMutError {
    #[cfg(feature = "debug_refcell")]
    location: &'static crate::panic::Location<'static>,
}

#[stable(feature = "try_borrow", since = "1.13.0")]
impl Debug for BorrowMutError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut builder = f.debug_struct("BorrowMutError");

        #[cfg(feature = "debug_refcell")]
        builder.field("location", self.location);

        builder.finish()
    }
}

#[stable(feature = "try_borrow", since = "1.13.0")]
impl Display for BorrowMutError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Display::fmt("already borrowed", f)
    }
}

// 正值表示 `Ref` 活跃的数量。负值表示 `RefMut` 活跃的数量。
// 多个 `RefMut`s 只能在一次激活,如果它们指的是不同的,`RefCell` 的非重叠组件 (例如,一个切片的不同范围)。
//
// `Ref` 和 `RefMut` 在大小上都是两个字符,因此可能永远不会有足够的 `Ref`s 或` RefMut`s 存在,以至于溢出 `usize` 范围的一半。
// 因此,`BorrowFlag` 可能永远不会上溢或下溢。
// 但是,这并不是一个保证,因为 pathological 程序可能会反复创建,然后 mem::forget `Ref`s 或 `RefMut`。
// 因此,所有代码都必须显式检查上溢和下溢,以避免不安全,或者至少在发生上溢或下溢的情况下正确运行 (例如,请参见 BorrowRef::new)。
//
//
//
//
//
//
type BorrowFlag = isize;
const UNUSED: BorrowFlag = 0;

#[inline(always)]
fn is_writing(x: BorrowFlag) -> bool {
    x < UNUSED
}

#[inline(always)]
fn is_reading(x: BorrowFlag) -> bool {
    x > UNUSED
}

impl<T> RefCell<T> {
    /// 创建一个包含 `value` 的新 `RefCell`。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new(5);
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_stable(feature = "const_refcell_new", since = "1.24.0")]
    #[inline]
    pub const fn new(value: T) -> RefCell<T> {
        RefCell {
            value: UnsafeCell::new(value),
            borrow: Cell::new(UNUSED),
            #[cfg(feature = "debug_refcell")]
            borrowed_at: Cell::new(None),
        }
    }

    /// 消耗 `RefCell`,返回包装的值。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new(5);
    ///
    /// let five = c.into_inner();
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_cell_into_inner", issue = "78729")]
    #[inline]
    pub const fn into_inner(self) -> T {
        // 由于此函数按值获取 `self` (`RefCell`),因此编译器静态地验证它当前没有被借用。
        //
        self.value.into_inner()
    }

    /// 将包装的值替换为新的值,并返回老的值,而无需对任何一个进行去初始化。
    ///
    ///
    /// 该函数对应于 [`std::mem::replace`](../mem/fn.replace.html)。
    ///
    /// # Panics
    ///
    /// 如果当前的值是借来的,就会出现 panic。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    /// let cell = RefCell::new(5);
    /// let old_value = cell.replace(6);
    /// assert_eq!(old_value, 5);
    /// assert_eq!(cell, RefCell::new(6));
    /// ```
    #[inline]
    #[stable(feature = "refcell_replace", since = "1.24.0")]
    #[track_caller]
    pub fn replace(&self, t: T) -> T {
        mem::replace(&mut *self.borrow_mut(), t)
    }

    /// 用从 `f` 计算出的新值替换包装后的值,并返回旧值,而无需对任何一个进行去初始化。
    ///
    ///
    /// # Panics
    ///
    /// 如果当前的值是借来的,就会出现 panic。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    /// let cell = RefCell::new(5);
    /// let old_value = cell.replace_with(|&mut old| old + 1);
    /// assert_eq!(old_value, 5);
    /// assert_eq!(cell, RefCell::new(6));
    /// ```
    #[inline]
    #[stable(feature = "refcell_replace_swap", since = "1.35.0")]
    #[track_caller]
    pub fn replace_with<F: FnOnce(&mut T) -> T>(&self, f: F) -> T {
        let mut_borrow = &mut *self.borrow_mut();
        let replacement = f(mut_borrow);
        mem::replace(mut_borrow, replacement)
    }

    /// 将 `self` 的包装值与 `other` 的包装值交换,而无需对任何一个进行去初始化。
    ///
    /// 该函数对应于 [`std::mem::swap`](../mem/fn.swap.html)。
    ///
    /// # Panics
    ///
    /// 如果当前借用了 `RefCell` 中的值,或者 `self` 和 `other` 指向相同的 `RefCell`,则会出现 panic。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    /// let c = RefCell::new(5);
    /// let d = RefCell::new(6);
    /// c.swap(&d);
    /// assert_eq!(c, RefCell::new(6));
    /// assert_eq!(d, RefCell::new(5));
    /// ```
    ///
    #[inline]
    #[stable(feature = "refcell_swap", since = "1.24.0")]
    pub fn swap(&self, other: &Self) {
        mem::swap(&mut *self.borrow_mut(), &mut *other.borrow_mut())
    }
}

impl<T: ?Sized> RefCell<T> {
    /// 不变地借用包装的值。
    ///
    /// 借用一直持续到返回的 `Ref` 退出作用域为止。
    /// 可以同时取出多个不可变借用。
    ///
    /// # Panics
    ///
    /// 如果当前价值是可变借来的,就会出现 panic。
    /// 对于没有 panic 的变体,请使用 [`try_borrow`](#method.try_borrow)。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new(5);
    ///
    /// let borrowed_five = c.borrow();
    /// let borrowed_five2 = c.borrow();
    /// ```
    ///
    /// panic 的一个例子:
    ///
    /// ```should_panic
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new(5);
    ///
    /// let m = c.borrow_mut();
    /// let b = c.borrow(); // 这导致 panic
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    #[track_caller]
    pub fn borrow(&self) -> Ref<'_, T> {
        self.try_borrow().expect("already mutably borrowed")
    }

    /// 不可变地借用包装的值,如果当前可变地借用该值,则返回错误。
    ///
    ///
    /// 借用一直持续到返回的 `Ref` 退出作用域为止。
    /// 可以同时取出多个不可变借用。
    ///
    /// 这是 [`borrow`](#method.borrow) 的没有 panic 的变体。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new(5);
    ///
    /// {
    ///     let m = c.borrow_mut();
    ///     assert!(c.try_borrow().is_err());
    /// }
    ///
    /// {
    ///     let m = c.borrow();
    ///     assert!(c.try_borrow().is_ok());
    /// }
    /// ```
    #[stable(feature = "try_borrow", since = "1.13.0")]
    #[inline]
    #[cfg_attr(feature = "debug_refcell", track_caller)]
    pub fn try_borrow(&self) -> Result<Ref<'_, T>, BorrowError> {
        match BorrowRef::new(&self.borrow) {
            Some(b) => {
                #[cfg(feature = "debug_refcell")]
                {
                    // `borrowed_at` 永远是第一个活动借用
                    if b.borrow.get() == 1 {
                        self.borrowed_at.set(Some(crate::panic::Location::caller()));
                    }
                }

                // SAFETY: `BorrowRef` 确保借用时只能不可变地访问该值。
                //
                let value = unsafe { NonNull::new_unchecked(self.value.get()) };
                Ok(Ref { value, borrow: b })
            }
            None => Err(BorrowError {
                // 如果发生了借用,那么我们一定已经有一个未偿还的借用,所以 `borrowed_at` 就是 `Some`
                //
                #[cfg(feature = "debug_refcell")]
                location: self.borrowed_at.get().unwrap(),
            }),
        }
    }

    /// 可变地借用包装的值。
    ///
    /// 借用一直持续到返回的 `RefMut` 或从中衍生的所有 `RefMut` 退出作用域为止。
    ///
    /// 该借用处于活动状态时,不能借用该值。
    ///
    /// # Panics
    ///
    /// 如果当前的值是借来的,就会出现 panic。
    /// 对于没有 panic 的变体,请使用 [`try_borrow_mut`](#method.try_borrow_mut)。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new("hello".to_owned());
    ///
    /// *c.borrow_mut() = "bonjour".to_owned();
    ///
    /// assert_eq!(&*c.borrow(), "bonjour");
    /// ```
    ///
    /// panic 的一个例子:
    ///
    /// ```should_panic
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new(5);
    /// let m = c.borrow();
    ///
    /// let b = c.borrow_mut(); // 这导致 panic
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    #[track_caller]
    pub fn borrow_mut(&self) -> RefMut<'_, T> {
        self.try_borrow_mut().expect("already borrowed")
    }

    /// 可变地借用包装的值,如果当前借用该值,则返回错误。
    ///
    ///
    /// 借用一直持续到返回的 `RefMut` 或从中衍生的所有 `RefMut` 退出作用域为止。
    /// 该借用处于活动状态时,不能借用该值。
    ///
    /// 这是 [`borrow_mut`](#method.borrow_mut) 的没有 panic 的变体。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new(5);
    ///
    /// {
    ///     let m = c.borrow();
    ///     assert!(c.try_borrow_mut().is_err());
    /// }
    ///
    /// assert!(c.try_borrow_mut().is_ok());
    /// ```
    #[stable(feature = "try_borrow", since = "1.13.0")]
    #[inline]
    #[cfg_attr(feature = "debug_refcell", track_caller)]
    pub fn try_borrow_mut(&self) -> Result<RefMut<'_, T>, BorrowMutError> {
        match BorrowRefMut::new(&self.borrow) {
            Some(b) => {
                #[cfg(feature = "debug_refcell")]
                {
                    self.borrowed_at.set(Some(crate::panic::Location::caller()));
                }

                // SAFETY: `BorrowRefMut` 保证唯一的访问。
                let value = unsafe { NonNull::new_unchecked(self.value.get()) };
                Ok(RefMut { value, borrow: b, marker: PhantomData })
            }
            None => Err(BorrowMutError {
                // 如果发生了借用,那么我们一定已经有一个未偿还的借用,所以 `borrowed_at` 就是 `Some`
                //
                #[cfg(feature = "debug_refcell")]
                location: self.borrowed_at.get().unwrap(),
            }),
        }
    }

    /// 返回指向此 cell 中底层数据的裸指针。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new(5);
    ///
    /// let ptr = c.as_ptr();
    /// ```
    #[inline]
    #[stable(feature = "cell_as_ptr", since = "1.12.0")]
    pub fn as_ptr(&self) -> *mut T {
        self.value.get()
    }

    /// 返回对底层数据的可变引用。
    ///
    /// 由于此方法可变地借用 `RefCell`,因此静态保证不存在对底层数据的借用。
    /// 因此,不需要 [`borrow_mut`] 和 `RefCell` 的大多数其他方法中固有的动态检查。
    ///
    /// 只有在 `RefCell` 可以可变借用时才能调用此方法,通常只有在创建 `RefCell` 后直接调用。
    ///
    /// 在这些情况下,跳过上述动态借用检查可能会产生更好的人体工程学和运行时性能。
    ///
    /// 在大多数使用 `RefCell` 的情况下,它不能被可变借用。
    /// 然后使用 [`borrow_mut`] 来获取对底层数据的非法访问。
    ///
    /// [`borrow_mut`]: RefCell::borrow_mut()
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    ///
    /// let mut c = RefCell::new(5);
    /// *c.get_mut() += 1;
    ///
    /// assert_eq!(c, RefCell::new(6));
    /// ```
    ///
    ///
    ///
    #[inline]
    #[stable(feature = "cell_get_mut", since = "1.11.0")]
    pub fn get_mut(&mut self) -> &mut T {
        self.value.get_mut()
    }

    /// 撤消泄漏的守卫对 `RefCell` 借用状态的影响。
    ///
    /// 这个调用与 [`get_mut`] 类似,但更专业。
    /// 它可变地借用 `RefCell` 以确保不存在借用,然后重置状态跟踪共享借用。
    /// 如果某些 `Ref` 或 `RefMut` 借用已被泄露,则这是相关的。
    ///
    /// [`get_mut`]: RefCell::get_mut()
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(cell_leak)]
    /// use std::cell::RefCell;
    ///
    /// let mut c = RefCell::new(0);
    /// std::mem::forget(c.borrow_mut());
    ///
    /// assert!(c.try_borrow().is_err());
    /// c.undo_leak();
    /// assert!(c.try_borrow().is_ok());
    /// ```
    #[unstable(feature = "cell_leak", issue = "69099")]
    pub fn undo_leak(&mut self) -> &mut T {
        *self.borrow.get_mut() = UNUSED;
        self.get_mut()
    }

    /// 不可变地借用包装的值,如果当前可变地借用该值,则返回错误。
    ///
    /// # Safety
    ///
    /// 与 `RefCell::borrow` 不同,此方法是不安全的,因为它不返回 `Ref`,从而使借用标志保持不变。
    /// 当此方法返回的引用仍然有效时,借用 `RefCell` 是未定义的行为。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new(5);
    ///
    /// {
    ///     let m = c.borrow_mut();
    ///     assert!(unsafe { c.try_borrow_unguarded() }.is_err());
    /// }
    ///
    /// {
    ///     let m = c.borrow();
    ///     assert!(unsafe { c.try_borrow_unguarded() }.is_ok());
    /// }
    /// ```
    ///
    ///
    ///
    #[stable(feature = "borrow_state", since = "1.37.0")]
    #[inline]
    pub unsafe fn try_borrow_unguarded(&self) -> Result<&T, BorrowError> {
        if !is_writing(self.borrow.get()) {
            // SAFETY: 我们检查现在没有人在主动写入,但是调用者有责任确保没有人写入,直到返回的引用不再使用。
            //
            // 同样,`self.value.get()` 是指 `self` 拥有的值,因此可以保证对于 `self` 的生命周期有效。
            //
            //
            Ok(unsafe { &*self.value.get() })
        } else {
            Err(BorrowError {
                // 如果发生了借用,那么我们一定已经有一个未偿还的借用,所以 `borrowed_at` 就是 `Some`
                //
                #[cfg(feature = "debug_refcell")]
                location: self.borrowed_at.get().unwrap(),
            })
        }
    }
}

impl<T: Default> RefCell<T> {
    /// 获取包装的值,将 `Default::default()` 留在其位置。
    ///
    /// # Panics
    ///
    /// 如果当前的值是借来的,就会出现 panic。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::RefCell;
    ///
    /// let c = RefCell::new(5);
    /// let five = c.take();
    ///
    /// assert_eq!(five, 5);
    /// assert_eq!(c.into_inner(), 0);
    /// ```
    #[stable(feature = "refcell_take", since = "1.50.0")]
    pub fn take(&self) -> T {
        self.replace(Default::default())
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized> Send for RefCell<T> where T: Send {}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !Sync for RefCell<T> {}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Clone> Clone for RefCell<T> {
    /// # Panics
    ///
    /// 如果当前价值是可变借来的,就会出现 panic。
    #[inline]
    #[track_caller]
    fn clone(&self) -> RefCell<T> {
        RefCell::new(self.borrow().clone())
    }

    /// # Panics
    ///
    /// 如果当前 `other` 是可变借用的,就会出现 panic。
    #[inline]
    #[track_caller]
    fn clone_from(&mut self, other: &Self) {
        self.get_mut().clone_from(&other.borrow())
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Default> Default for RefCell<T> {
    /// 创建一个 `RefCell<T>`,其 T 值为 `Default`。
    #[inline]
    fn default() -> RefCell<T> {
        RefCell::new(Default::default())
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized + PartialEq> PartialEq for RefCell<T> {
    /// # Panics
    ///
    /// 如果 `RefCell` 中的值当前被可变地借用,则会出现 panic。
    #[inline]
    fn eq(&self, other: &RefCell<T>) -> bool {
        *self.borrow() == *other.borrow()
    }
}

#[stable(feature = "cell_eq", since = "1.2.0")]
impl<T: ?Sized + Eq> Eq for RefCell<T> {}

#[stable(feature = "cell_ord", since = "1.10.0")]
impl<T: ?Sized + PartialOrd> PartialOrd for RefCell<T> {
    /// # Panics
    ///
    /// 如果 `RefCell` 中的值当前被可变地借用,则会出现 panic。
    #[inline]
    fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering> {
        self.borrow().partial_cmp(&*other.borrow())
    }

    /// # Panics
    ///
    /// 如果 `RefCell` 中的值当前被可变地借用,则会出现 panic。
    #[inline]
    fn lt(&self, other: &RefCell<T>) -> bool {
        *self.borrow() < *other.borrow()
    }

    /// # Panics
    ///
    /// 如果 `RefCell` 中的值当前被可变地借用,则会出现 panic。
    #[inline]
    fn le(&self, other: &RefCell<T>) -> bool {
        *self.borrow() <= *other.borrow()
    }

    /// # Panics
    ///
    /// 如果 `RefCell` 中的值当前被可变地借用,则会出现 panic。
    #[inline]
    fn gt(&self, other: &RefCell<T>) -> bool {
        *self.borrow() > *other.borrow()
    }

    /// # Panics
    ///
    /// 如果 `RefCell` 中的值当前被可变地借用,则会出现 panic。
    #[inline]
    fn ge(&self, other: &RefCell<T>) -> bool {
        *self.borrow() >= *other.borrow()
    }
}

#[stable(feature = "cell_ord", since = "1.10.0")]
impl<T: ?Sized + Ord> Ord for RefCell<T> {
    /// # Panics
    ///
    /// 如果 `RefCell` 中的值当前被可变地借用,则会出现 panic。
    #[inline]
    fn cmp(&self, other: &RefCell<T>) -> Ordering {
        self.borrow().cmp(&*other.borrow())
    }
}

#[stable(feature = "cell_from", since = "1.12.0")]
impl<T> From<T> for RefCell<T> {
    /// 创建一个包含给定值的新 `RefCell<T>`。
    fn from(t: T) -> RefCell<T> {
        RefCell::new(t)
    }
}

#[unstable(feature = "coerce_unsized", issue = "18598")]
impl<T: CoerceUnsized<U>, U> CoerceUnsized<RefCell<U>> for RefCell<T> {}

struct BorrowRef<'b> {
    borrow: &'b Cell<BorrowFlag>,
}

impl<'b> BorrowRef<'b> {
    #[inline]
    fn new(borrow: &'b Cell<BorrowFlag>) -> Option<BorrowRef<'b>> {
        let b = borrow.get().wrapping_add(1);
        if !is_reading(b) {
            // 在以下情况下,增加借用可能会导致未读值 (<= 0):
            // 1. 它小于 0,即正在写借用,因此由于 Rust 的引用别名规则,我们不允许读取借用
            // 2.
            // 它是 isize::MAX (最大读取借用量),并且溢出到 isize::MIN (最大写入借用量) 中,因此我们不允许额外的读取借用,因为 isize 不能表示那么多读取借用 (这只能在以下情况下发生:您的 mem::forget 大于常量的少量常量,这不是很好的做法)
            //
            //
            //
            //
            None
        } else {
            // 在以下情况下,增加借用可能会导致读取值 (> 0) :
            // 1. 它是 = 0,即它不是借来的,我们正在进行第一次读取借用
            // 2. 它是 > 0 且 < isize::MAX,即
            // 有 read 借用,并且 isize 足够大,可以代表再有一次 read 借用
            borrow.set(b);
            Some(BorrowRef { borrow })
        }
    }
}

impl Drop for BorrowRef<'_> {
    #[inline]
    fn drop(&mut self) {
        let borrow = self.borrow.get();
        debug_assert!(is_reading(borrow));
        self.borrow.set(borrow - 1);
    }
}

impl Clone for BorrowRef<'_> {
    #[inline]
    fn clone(&self) -> Self {
        // 由于该 Ref 存在,因此我们知道借用标志是 reading 借用。
        //
        let borrow = self.borrow.get();
        debug_assert!(is_reading(borrow));
        // 防止借用计数器溢出到 writing 借用中。
        //
        assert!(borrow != isize::MAX);
        self.borrow.set(borrow + 1);
        BorrowRef { borrow: self.borrow }
    }
}

/// 在 `RefCell` box 中将借用的引用括起来。
/// 从 `RefCell<T>` 不变借来的值的包装器类型。
///
/// 有关更多信息,请参见 [模块级文档](self)。
#[stable(feature = "rust1", since = "1.0.0")]
#[must_not_suspend = "holding a Ref across suspend points can cause BorrowErrors"]
pub struct Ref<'b, T: ?Sized + 'b> {
    // NB: 我们使用指针而不是 `&'b T` 来避免违反 `noalias`,因为 `Ref` 参数并不在其整个作用域内保持不变性,只是在它被丢弃之前才具有不变性。
    //
    // `NonNull` 在 `T` 上也是协变的,就像我们对 `&T` 所做的那样。
    value: NonNull<T>,
    borrow: BorrowRef<'b>,
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> Deref for Ref<'_, T> {
    type Target = T;

    #[inline]
    fn deref(&self) -> &T {
        // SAFETY: 只要我们持有我们的借用,值就可以被访问到。
        unsafe { self.value.as_ref() }
    }
}

impl<'b, T: ?Sized> Ref<'b, T> {
    /// 复制一个 `Ref`。
    ///
    /// `RefCell` 已经被不可改变地借用了,因此这不会失败。
    ///
    /// 这是一个关联函数,需要用作 `Ref::clone(...)`。
    /// `Clone` 的实现或方法将干扰 `r.borrow().clone()` 的广泛使用,以克隆 `RefCell` 的内容。
    ///
    ///
    #[stable(feature = "cell_extras", since = "1.15.0")]
    #[must_use]
    #[inline]
    pub fn clone(orig: &Ref<'b, T>) -> Ref<'b, T> {
        Ref { value: orig.value, borrow: orig.borrow.clone() }
    }

    /// 为借用数据的组件制作新的 `Ref`。
    ///
    /// `RefCell` 已经被不可改变地借用了,因此这不会失败。
    ///
    /// 这是一个关联函数,需要用作 `Ref::map(...)`。
    /// 方法会干扰通过 `Deref` 使用的 `RefCell` 内容中的同名方法。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::{RefCell, Ref};
    ///
    /// let c = RefCell::new((5, 'b'));
    /// let b1: Ref<'_, (u32, char)> = c.borrow();
    /// let b2: Ref<'_, u32> = Ref::map(b1, |t| &t.0);
    /// assert_eq!(*b2, 5)
    /// ```
    #[stable(feature = "cell_map", since = "1.8.0")]
    #[inline]
    pub fn map<U: ?Sized, F>(orig: Ref<'b, T>, f: F) -> Ref<'b, U>
    where
        F: FnOnce(&T) -> &U,
    {
        Ref { value: NonNull::from(f(&*orig)), borrow: orig.borrow }
    }

    /// 为借用数据的可选组件制作新的 `Ref`。
    /// 如果闭包返回 `None`,则原始守卫将作为 `Err(..)` 返回。
    ///
    /// `RefCell` 已经被不可改变地借用了,因此这不会失败。
    ///
    /// 这是一个关联函数,需要用作 `Ref::filter_map(...)`。
    /// 方法会干扰通过 `Deref` 使用的 `RefCell` 内容中的同名方法。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::{RefCell, Ref};
    ///
    /// let c = RefCell::new(vec![1, 2, 3]);
    /// let b1: Ref<'_, Vec<u32>> = c.borrow();
    /// let b2: Result<Ref<'_, u32>, _> = Ref::filter_map(b1, |v| v.get(1));
    /// assert_eq!(*b2.unwrap(), 2);
    /// ```
    ///
    #[stable(feature = "cell_filter_map", since = "1.63.0")]
    #[inline]
    pub fn filter_map<U: ?Sized, F>(orig: Ref<'b, T>, f: F) -> Result<Ref<'b, U>, Self>
    where
        F: FnOnce(&T) -> Option<&U>,
    {
        match f(&*orig) {
            Some(value) => Ok(Ref { value: NonNull::from(value), borrow: orig.borrow }),
            None => Err(orig),
        }
    }

    /// 将 `Ref` 拆分为多个 `Ref`,以用于借用数据的不同组成部分。
    ///
    /// `RefCell` 已经被不可改变地借用了,因此这不会失败。
    ///
    /// 这是一个关联函数,需要用作 `Ref::map_split(...)`。
    /// 方法会干扰通过 `Deref` 使用的 `RefCell` 内容中的同名方法。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::{Ref, RefCell};
    ///
    /// let cell = RefCell::new([1, 2, 3, 4]);
    /// let borrow = cell.borrow();
    /// let (begin, end) = Ref::map_split(borrow, |slice| slice.split_at(2));
    /// assert_eq!(*begin, [1, 2]);
    /// assert_eq!(*end, [3, 4]);
    /// ```
    ///
    #[stable(feature = "refcell_map_split", since = "1.35.0")]
    #[inline]
    pub fn map_split<U: ?Sized, V: ?Sized, F>(orig: Ref<'b, T>, f: F) -> (Ref<'b, U>, Ref<'b, V>)
    where
        F: FnOnce(&T) -> (&U, &V),
    {
        let (a, b) = f(&*orig);
        let borrow = orig.borrow.clone();
        (
            Ref { value: NonNull::from(a), borrow },
            Ref { value: NonNull::from(b), borrow: orig.borrow },
        )
    }

    /// 转换为对底层数据的引用。
    ///
    /// 底层的 `RefCell` 永远不会再被可变借用,并且总是看起来已经是不可更改的借用。
    ///
    /// 泄漏超过一定数量的引用不是一个好主意。
    /// 如果总共只发生了少量的泄漏,则可以再次借用 `RefCell`。
    ///
    /// 这是一个关联函数,需要用作 `Ref::leak(...)`。
    /// 方法会干扰通过 `Deref` 使用的 `RefCell` 内容中的同名方法。
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(cell_leak)]
    /// use std::cell::{RefCell, Ref};
    /// let cell = RefCell::new(0);
    ///
    /// let value = Ref::leak(cell.borrow());
    /// assert_eq!(*value, 0);
    ///
    /// assert!(cell.try_borrow().is_ok());
    /// assert!(cell.try_borrow_mut().is_err());
    /// ```
    ///
    #[unstable(feature = "cell_leak", issue = "69099")]
    pub fn leak(orig: Ref<'b, T>) -> &'b T {
        // 通过忘记此引用,我们确保 RefCell 中的借用计数器不会返回到生命周期 `'b` 中的未使用状态。
        // 重置引用跟踪状态将需要对借用的 RefCell 进行唯一引用。
        // 无法从原始 cell 创建更多的可变引用。
        //
        mem::forget(orig.borrow);
        // SAFETY: 忘记之后,我们可以为剩余的生命周期 `'b` 形成一个引用。
        unsafe { orig.value.as_ref() }
    }
}

#[unstable(feature = "coerce_unsized", issue = "18598")]
impl<'b, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Ref<'b, U>> for Ref<'b, T> {}

#[stable(feature = "std_guard_impls", since = "1.20.0")]
impl<T: ?Sized + fmt::Display> fmt::Display for Ref<'_, T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        (**self).fmt(f)
    }
}

impl<'b, T: ?Sized> RefMut<'b, T> {
    /// 为借用数据的一个组件 (例如一个枚举变体) 创建一个新的 `RefMut`。
    ///
    /// `RefCell` 已经是可变借用的,因此这不会失败。
    ///
    /// 这是一个关联函数,需要用作 `RefMut::map(...)`。
    /// 方法会干扰通过 `Deref` 使用的 `RefCell` 内容中的同名方法。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::{RefCell, RefMut};
    ///
    /// let c = RefCell::new((5, 'b'));
    /// {
    ///     let b1: RefMut<'_, (u32, char)> = c.borrow_mut();
    ///     let mut b2: RefMut<'_, u32> = RefMut::map(b1, |t| &mut t.0);
    ///     assert_eq!(*b2, 5);
    ///     *b2 = 42;
    /// }
    /// assert_eq!(*c.borrow(), (42, 'b'));
    /// ```
    ///
    #[stable(feature = "cell_map", since = "1.8.0")]
    #[inline]
    pub fn map<U: ?Sized, F>(mut orig: RefMut<'b, T>, f: F) -> RefMut<'b, U>
    where
        F: FnOnce(&mut T) -> &mut U,
    {
        let value = NonNull::from(f(&mut *orig));
        RefMut { value, borrow: orig.borrow, marker: PhantomData }
    }

    /// 为借用数据的可选组件制作新的 `RefMut`。
    /// 如果闭包返回 `None`,则原始守卫将作为 `Err(..)` 返回。
    ///
    /// `RefCell` 已经是可变借用的,因此这不会失败。
    ///
    /// 这是一个关联函数,需要用作 `RefMut::filter_map(...)`。
    /// 方法会干扰通过 `Deref` 使用的 `RefCell` 内容中的同名方法。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::{RefCell, RefMut};
    ///
    /// let c = RefCell::new(vec![1, 2, 3]);
    ///
    /// {
    ///     let b1: RefMut<'_, Vec<u32>> = c.borrow_mut();
    ///     let mut b2: Result<RefMut<'_, u32>, _> = RefMut::filter_map(b1, |v| v.get_mut(1));
    ///
    ///     if let Ok(mut b2) = b2 {
    ///         *b2 += 2;
    ///     }
    /// }
    ///
    /// assert_eq!(*c.borrow(), vec![1, 4, 3]);
    /// ```
    ///
    #[stable(feature = "cell_filter_map", since = "1.63.0")]
    #[inline]
    pub fn filter_map<U: ?Sized, F>(mut orig: RefMut<'b, T>, f: F) -> Result<RefMut<'b, U>, Self>
    where
        F: FnOnce(&mut T) -> Option<&mut U>,
    {
        // SAFETY: 在通过 `orig` 进行调用的过程中,函数将保留排他引用,并且仅在函数调用内部取消对指针的引用,而永不允许对排他引用进行转义。
        //
        //
        //
        match f(&mut *orig) {
            Some(value) => {
                Ok(RefMut { value: NonNull::from(value), borrow: orig.borrow, marker: PhantomData })
            }
            None => Err(orig),
        }
    }

    /// 将 `RefMut` 拆分为多个 `RefMut`,以用于借用数据的不同组成部分。
    ///
    /// 底层 `RefCell` 将保持可变借用状态,直到两个返回的 RefMut 离开作用域。
    ///
    /// `RefCell` 已经是可变借用的,因此这不会失败。
    ///
    /// 这是一个关联函数,需要用作 `RefMut::map_split(...)`。
    /// 方法会干扰通过 `Deref` 使用的 `RefCell` 内容中的同名方法。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::{RefCell, RefMut};
    ///
    /// let cell = RefCell::new([1, 2, 3, 4]);
    /// let borrow = cell.borrow_mut();
    /// let (mut begin, mut end) = RefMut::map_split(borrow, |slice| slice.split_at_mut(2));
    /// assert_eq!(*begin, [1, 2]);
    /// assert_eq!(*end, [3, 4]);
    /// begin.copy_from_slice(&[4, 3]);
    /// end.copy_from_slice(&[2, 1]);
    /// ```
    ///
    ///
    #[stable(feature = "refcell_map_split", since = "1.35.0")]
    #[inline]
    pub fn map_split<U: ?Sized, V: ?Sized, F>(
        mut orig: RefMut<'b, T>,
        f: F,
    ) -> (RefMut<'b, U>, RefMut<'b, V>)
    where
        F: FnOnce(&mut T) -> (&mut U, &mut V),
    {
        let borrow = orig.borrow.clone();
        let (a, b) = f(&mut *orig);
        (
            RefMut { value: NonNull::from(a), borrow, marker: PhantomData },
            RefMut { value: NonNull::from(b), borrow: orig.borrow, marker: PhantomData },
        )
    }

    /// 转换为底层数据的可变引用。
    ///
    /// 底层 `RefCell` 不能再次借用,并且将始终显示为已经被可变借用,使得返回的引用成为内部的唯一引用。
    ///
    ///
    /// 这是一个关联函数,需要用作 `RefMut::leak(...)`。
    /// 方法会干扰通过 `Deref` 使用的 `RefCell` 内容中的同名方法。
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(cell_leak)]
    /// use std::cell::{RefCell, RefMut};
    /// let cell = RefCell::new(0);
    ///
    /// let value = RefMut::leak(cell.borrow_mut());
    /// assert_eq!(*value, 0);
    /// *value = 1;
    ///
    /// assert!(cell.try_borrow_mut().is_err());
    /// ```
    ///
    #[unstable(feature = "cell_leak", issue = "69099")]
    pub fn leak(mut orig: RefMut<'b, T>) -> &'b mut T {
        // 通过忘记此 BorrowRefMut,我们确保 RefCell 中的借用计数器不能在生命周期 `'b` 内返回未使用状态。
        // 重置引用跟踪状态将需要对借用的 RefCell 进行唯一引用。
        // 无法从该生命周期内的原始 cell 中创建更多引用,从而使当前借用成为剩余生命周期的唯一引用。
        //
        //
        mem::forget(orig.borrow);
        // SAFETY: 忘记之后,我们可以为剩余的生命周期 `'b` 形成一个引用。
        unsafe { orig.value.as_mut() }
    }
}

struct BorrowRefMut<'b> {
    borrow: &'b Cell<BorrowFlag>,
}

impl Drop for BorrowRefMut<'_> {
    #[inline]
    fn drop(&mut self) {
        let borrow = self.borrow.get();
        debug_assert!(is_writing(borrow));
        self.borrow.set(borrow + 1);
    }
}

impl<'b> BorrowRefMut<'b> {
    #[inline]
    fn new(borrow: &'b Cell<BorrowFlag>) -> Option<BorrowRefMut<'b>> {
        // NOTE: 与 BorrowRefMut::clone 不同,调用 new 来创建初始变量引用,因此当前必须不存在引用。
        // 因此,虽然克隆增加了可变引用计数,但这里我们明确地只允许从 UNUSED 到 UNUSED- 1.
        //
        //
        match borrow.get() {
            UNUSED => {
                borrow.set(UNUSED - 1);
                Some(BorrowRefMut { borrow })
            }
            _ => None,
        }
    }

    // 克隆 `BorrowRefMut`。
    //
    // 仅当每个 `BorrowRefMut` 用于跟踪变量引用到原始对象的不同的,不重叠的范围时,此方法才有效。
    //
    // 这不在 Clone 隐含中,因此代码不会隐式调用此代码。
    #[inline]
    fn clone(&self) -> BorrowRefMut<'b> {
        let borrow = self.borrow.get();
        debug_assert!(is_writing(borrow));
        // 防止借用计数器下溢。
        assert!(borrow != isize::MIN);
        self.borrow.set(borrow - 1);
        BorrowRefMut { borrow: self.borrow }
    }
}

/// 从 `RefCell<T>` 可变借来的值的包装器类型。
///
/// 有关更多信息,请参见 [模块级文档](self)。
#[stable(feature = "rust1", since = "1.0.0")]
#[must_not_suspend = "holding a RefMut across suspend points can cause BorrowErrors"]
pub struct RefMut<'b, T: ?Sized + 'b> {
    // NB: 我们使用指针而不是 `&'b mut T` 来避免违反 `noalias`,因为 `RefMut` 参数不对其整个作用域保持排他性,仅在它丢弃之前。
    //
    value: NonNull<T>,
    borrow: BorrowRefMut<'b>,
    // `NonNull` 在 `T` 上是协变的,所以我们需要重新引入不变性。
    marker: PhantomData<&'b mut T>,
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> Deref for RefMut<'_, T> {
    type Target = T;

    #[inline]
    fn deref(&self) -> &T {
        // SAFETY: 只要我们持有我们的借用,值就可以被访问到。
        unsafe { self.value.as_ref() }
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> DerefMut for RefMut<'_, T> {
    #[inline]
    fn deref_mut(&mut self) -> &mut T {
        // SAFETY: 只要我们持有我们的借用,值就可以被访问到。
        unsafe { self.value.as_mut() }
    }
}

#[unstable(feature = "coerce_unsized", issue = "18598")]
impl<'b, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<RefMut<'b, U>> for RefMut<'b, T> {}

#[stable(feature = "std_guard_impls", since = "1.20.0")]
impl<T: ?Sized + fmt::Display> fmt::Display for RefMut<'_, T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        (**self).fmt(f)
    }
}

/// Rust 中内部可变性的核心原语。
///
/// 如果您使用的是 `&T`,则通常在 Rust 中,编译器基于 `&T` 指向不可变数据的知识来执行优化。例如通过别名或通过将 `&T` 转换为 `&mut T` 来可变的该数据,被认为是未定义的行为。
/// `UnsafeCell<T>` 选择退出 `&T` 的不可变性保证:共享的引用 `&UnsafeCell<T>` 可能指向正在发生可变的数据。这称为内部可变性。
///
/// 所有其他允许内部可变性的类型,例如 [`Cell<T>`] 和 [`RefCell<T>`],在内部使用 `UnsafeCell` 来包装它们的数据。
///
/// 请注意,仅 `UnsafeCell` 会影响共享引证的不可变性保证。可变引用的唯一性保证不受影响。没有合法的方法来获得 `&mut` 的别名,即使使用 `UnsafeCell<T>` 也没有。
///
/// `UnsafeCell` API 本身在技术上非常简单: [`.get()`] 为其内容提供了裸指针 `*mut T`。正确使用该裸指针取决于您。
///
/// [`.get()`]: `UnsafeCell::get`
///
/// 精确的 Rust 别名规则有些变化,但是要点并不存在争议:
///
/// - 如果您使用生命周期 `'a` (`&T` 或 `&mut T` 引用) 创建安全引用,那么您不得以任何与 `'a` 其余部分的引用相矛盾的方式访问数据。
/// 例如,这意味着如果您从 `UnsafeCell<T>` 中取出 `*mut T` 并将其转换为 `&T`,则 `T` 中的数据必须保持不可变 (当然,对 `T` 中找到的任何 `UnsafeCell` 数据取模),直到引用的生命周期到期为止。
/// 同样,如果您创建的 `&mut T` 引用已发布为安全代码,则在引用终止之前,您不得访问 `UnsafeCell` 中的数据。
///
/// - 对于没有 `UnsafeCell<_>` 的 `&T` 和 `&mut T`,在引用过期之前,您也不得释放数据。作为一个特殊的例外,给定一个 `&T`,它在 `UnsafeCell<_>` 内的任何部分都可能在引用的生命周期期间被释放,在最后一次使用引用之后 (解引用或重新借用)。
/// 因为您不能释放引用指向的部分,这意味着只有当*它的每一部分* (包括填充) 都在 `UnsafeCell` 中时,`&T` 指向的内存才能被释放。
///
///     但是,无论何时构造或解引用 `&UnsafeCell<T>`,它仍必须指向活动内存,并且如果编译器可以证明该内存尚未被释放,则允许编译器插入虚假读取。
///
/// - 在任何时候,您都必须避免数据竞争。如果多个线程可以访问同一个 `UnsafeCell`,那么任何写操作都必须在与所有其他访问 (或使用原子) 相关之前发生正确的事件。
///
/// 为了帮助进行正确的设计,以下情况明确声明为单线程代码合法:
///
/// 1. `&T` 引用可以释放为安全代码,并且可以与其他 `&T` 引用共存,但不能与 `&mut T` 共存
///
/// 2. `&mut T` 引用可以发布为安全代码,前提是其他 `&mut T` 和 `&T` 都不共存。`&mut T` 必须始终是唯一的。
///
/// 请注意,虽然可以更改 `&UnsafeCell<T>` 的内容 (即使其他 `&UnsafeCell<T>` 引用了该 cell 的别名) 也可以 (只要以其他方式实现上述不变量即可),但是具有多个 `&mut UnsafeCell<T>` 别名仍然是未定义的行为。
/// 也就是说,`UnsafeCell` 是一个包装器,旨在通过 `&UnsafeCell<_>` 与 _shared_ accesses (_i.e._ 进行特殊交互 (引用) ; 通过 `&mut UnsafeCell<_>` 处理 _exclusive_ accesses (_e.g._ 时没有任何魔术) : 在该 `&mut` 借用期间, cell 和包装值都不能被别名。
///
/// [`.get_mut()`] 访问器展示了这一点,该访问器是产生 `&mut T` 的 _safe_ getter。
///
/// [`.get_mut()`]: `UnsafeCell::get_mut`
///
/// # 内存布局
///
/// `UnsafeCell<T>` 与其内部类型 `T` 具有相同的内存表示。此保证的结果是可以在 `T` 和 `UnsafeCell<T>` 之间进行转换。
/// 将 `Outer<T>` 类型内的嵌套 `T` 转换为 `Outer<UnsafeCell<T>>` 类型时必须特别小心: 当 `Outer<T>` 类型启用 [niche] 优化时,这不是正确的。例如,类型 `Option<NonNull<u8>>` 通常是 8 字节大
/// 64 位平台,但 `Option<UnsafeCell<NonNull<u8>>>` 类型占用 16 字节空间。
/// 因此,这不是有效的转换,尽管 `NonNull<u8>` 和 `UnsafeCell<NonNull<u8>>>` 具有相同的内存布局。这是因为 `UnsafeCell` 禁用了 niche 优化,以避免其内部错误性属性从 `T` 传播到 `Outer` 类型,因此在这些情况下这可能导致类型大小的失真。
///
/// 请注意,获取指向共享 `UnsafeCell<T>` 内容的 `*mut T` 指针的唯一有效方法是通过 [`.get()`] 或 [`.raw_get()`]。`&mut T` 引用可以通过解引用 this 指针或通过在独占 `UnsafeCell<T>` 上调用 [`.get_mut()`] 来获得。
/// 即使 `T` 和 `UnsafeCell<T>` 具有相同的内存布局,以下是不允许的和未定义的行为:
///
/// ```rust,no_run
/// # use std::cell::UnsafeCell;
/// unsafe fn not_allowed<T>(ptr: &UnsafeCell<T>) -> &mut T {
///   let t = ptr as *const UnsafeCell<T> as *mut T;
///   // 这是未定义的行为,因为 `*mut T` 指针不是通过 `.get()` 或 `.raw_get()` 获得的:
/////
///   unsafe { &mut *t }
/// }
/// ```
///
/// 相反,请执行以下操作:
///
/// ```rust
/// # use std::cell::UnsafeCell;
/// // 安全: 调用者必须确保没有引用指向 `UnsafeCell` 的*内容*。
/////
/// unsafe fn get_mut<T>(ptr: &UnsafeCell<T>) -> &mut T {
///   unsafe { &mut *ptr.get() }
/// }
/// ```
///
/// 允许在另一个方向从 `&mut T` 转换为 `&UnsafeCell<T>`:
///
/// ```rust
/// # use std::cell::UnsafeCell;
/// fn get_shared<T>(ptr: &mut T) -> &UnsafeCell<T> {
///   let t = ptr as *mut T as *const UnsafeCell<T>;
///   // SAFETY: `T` 和 `UnsafeCell<T>` 具有相同的内存布局
///   unsafe { &*t }
/// }
/// ```
///
/// [niche]: https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#niche
/// [`.raw_get()`]: `UnsafeCell::raw_get`
///
/// # Examples
///
/// 这是一个示例,展示了如何对 `UnsafeCell<_>` 的内容进行合理的可变的,尽管该 cell 存在多个引用别名:
///
/// ```
/// use std::cell::UnsafeCell;
///
/// let x: UnsafeCell<i32> = 42.into();
/// // 对同一个 `x` 获取多个 / 并发 / 共享引用。
/// let (p1, p2): (&UnsafeCell<i32>, &UnsafeCell<i32>) = (&x, &x);
///
/// unsafe {
///     // SAFETY: 在此作用域内,对 x 的内容没有其他引用,因此我们的内容实际上是唯一的。
/////
///     let p1_exclusive: &mut i32 = &mut *p1.get(); // -- 借用 --+
///     *p1_exclusive += 27; // |
/// } // <---------- 不能超出这一点 --- ----------------+
///
/// unsafe {
///     // SAFETY: 在此作用域内,没有人期望对 x 的内容具有独占访问权,因此我们可以同时进行多个共享访问。
/////
///     let p2_shared: &i32 = &*p2.get();
///     assert_eq!(*p2_shared, 42 + 27);
///     let p1_shared: &i32 = &*p1.get();
///     assert_eq!(*p1_shared, *p2_shared);
/// }
/// ```
///
/// 以下示例展示了对 `UnsafeCell<T>` 的独占访问意味着对其 `T` 的独占访问的事实:
///
/// ```rust
/// #![forbid(unsafe_code)] // 具有独占访问权,
///                         // `UnsafeCell` 是一个透明的无操作包装器,所以这里不需要 `unsafe`。
/////
/// use std::cell::UnsafeCell;
///
/// let mut x: UnsafeCell<i32> = 42.into();
///
/// // 获得对 `x` 进行编译时检查的唯一引用。
/// let p_unique: &mut UnsafeCell<i32> = &mut x;
/// // 使用独家引用,我们可以免费更改内容。
/// *p_unique.get_mut() = 0;
/// // 或者,等效地:
/// x = UnsafeCell::new(0);
///
/// // 当我们拥有该值时,我们可以免费提取内容。
/// let contents: i32 = x.into_inner();
/// assert_eq!(contents, 0);
/// ```
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
#[lang = "unsafe_cell"]
#[stable(feature = "rust1", since = "1.0.0")]
#[repr(transparent)]
pub struct UnsafeCell<T: ?Sized> {
    value: T,
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !Sync for UnsafeCell<T> {}

impl<T> UnsafeCell<T> {
    /// 创建 `UnsafeCell` 的新实例,该实例将包装指定的值。
    ///
    ///
    /// 所有通过 `&UnsafeCell<T>` 访问内部值都需要 `unsafe` 代码。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::UnsafeCell;
    ///
    /// let uc = UnsafeCell::new(5);
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_stable(feature = "const_unsafe_cell_new", since = "1.32.0")]
    #[inline(always)]
    pub const fn new(value: T) -> UnsafeCell<T> {
        UnsafeCell { value }
    }

    /// 解开值,消耗 cell。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::UnsafeCell;
    ///
    /// let uc = UnsafeCell::new(5);
    ///
    /// let five = uc.into_inner();
    /// ```
    #[inline(always)]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_cell_into_inner", issue = "78729")]
    pub const fn into_inner(self) -> T {
        self.value
    }
}

impl<T: ?Sized> UnsafeCell<T> {
    /// 从 `&mut T` 转换为 `&mut UnsafeCell<T>`。
    ///
    /// # Examples
    ///
    /// ```
    /// # #![feature(unsafe_cell_from_mut)]
    /// use std::cell::UnsafeCell;
    ///
    /// let mut val = 42;
    /// let uc = UnsafeCell::from_mut(&mut val);
    ///
    /// *uc.get_mut() -= 1;
    /// assert_eq!(*uc.get_mut(), 41);
    /// ```
    #[inline(always)]
    #[unstable(feature = "unsafe_cell_from_mut", issue = "111645")]
    pub const fn from_mut(value: &mut T) -> &mut UnsafeCell<T> {
        // SAFETY: 由于 #[repr(transparent)],`UnsafeCell<T>` 与 `T` 具有相同的内存布局。
        unsafe { &mut *(value as *mut T as *mut UnsafeCell<T>) }
    }

    /// 获取指向包装值的可变指针。
    ///
    /// 可以将其强制转换为任何类型的指针。
    /// 强制转换为 `&mut T` 时,访问是唯一的 (无活跃的引用,可变或不活动),并确保转换为 `&T` 时没有发生任何可变的或可变别名。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::UnsafeCell;
    ///
    /// let uc = UnsafeCell::new(5);
    ///
    /// let five = uc.get();
    /// ```
    ///
    #[inline(always)]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_stable(feature = "const_unsafecell_get", since = "1.32.0")]
    pub const fn get(&self) -> *mut T {
        // 由于 #[repr(transparent)],我们只能将指针从 `UnsafeCell<T>` 转换为 `T`。
        // 这利用了 std 的特殊状态,不能保证用户代码可以在 future 版本的编译器中工作!
        //
        self as *const UnsafeCell<T> as *const T as *mut T
    }

    /// 返回对底层数据的可变引用。
    ///
    /// 这个调用借用 `UnsafeCell` (在编译时) 是可变的,这保证了我们拥有唯一的引用。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::cell::UnsafeCell;
    ///
    /// let mut c = UnsafeCell::new(5);
    /// *c.get_mut() += 1;
    ///
    /// assert_eq!(*c.get_mut(), 6);
    /// ```
    #[inline(always)]
    #[stable(feature = "unsafe_cell_get_mut", since = "1.50.0")]
    #[rustc_const_unstable(feature = "const_unsafecell_get_mut", issue = "88836")]
    pub const fn get_mut(&mut self) -> &mut T {
        &mut self.value
    }

    /// 获取指向包装值的可变指针。
    /// 与 [`get`] 的不同之处在于该函数接受一个裸指针,这有助于避免创建临时引用。
    ///
    /// 结果可以转换为任何类型的指针。
    /// 强制转换为 `&mut T` 时,访问是唯一的 (无活跃的引用,可变性或非活动性),并确保转换为 `&T` 时没有发生任何可变的或可变别名。
    ///
    ///
    /// [`get`]: UnsafeCell::get()
    ///
    /// # Examples
    ///
    /// `UnsafeCell` 的逐步初始化需要 `raw_get`,因为调用 `get` 需要对未初始化的数据创建引用:
    ///
    /// ```
    /// use std::cell::UnsafeCell;
    /// use std::mem::MaybeUninit;
    ///
    /// let m = MaybeUninit::<UnsafeCell<i32>>::uninit();
    /// unsafe { UnsafeCell::raw_get(m.as_ptr()).write(5); }
    /// // avoid below which 引用未初始化的数据 unsafe { UnsafeCell::get(&*m.as_ptr()).write(5); }
    /////
    /// let uc = unsafe { m.assume_init() };
    ///
    /// assert_eq!(uc.into_inner(), 5);
    /// ```
    ///
    ///
    ///
    #[inline(always)]
    #[stable(feature = "unsafe_cell_raw_get", since = "1.56.0")]
    #[rustc_const_stable(feature = "unsafe_cell_raw_get", since = "1.56.0")]
    pub const fn raw_get(this: *const Self) -> *mut T {
        // 由于 #[repr(transparent)],我们只能将指针从 `UnsafeCell<T>` 转换为 `T`。
        // 这利用了 std 的特殊状态,不能保证用户代码可以在 future 版本的编译器中工作!
        //
        this as *const T as *mut T
    }
}

#[stable(feature = "unsafe_cell_default", since = "1.10.0")]
impl<T: Default> Default for UnsafeCell<T> {
    /// 创建一个 `UnsafeCell`,其 T 值为 `Default`。
    fn default() -> UnsafeCell<T> {
        UnsafeCell::new(Default::default())
    }
}

#[stable(feature = "cell_from", since = "1.12.0")]
impl<T> From<T> for UnsafeCell<T> {
    /// 创建一个包含给定值的新 `UnsafeCell<T>`。
    fn from(t: T) -> UnsafeCell<T> {
        UnsafeCell::new(t)
    }
}

#[unstable(feature = "coerce_unsized", issue = "18598")]
impl<T: CoerceUnsized<U>, U> CoerceUnsized<UnsafeCell<U>> for UnsafeCell<T> {}

// 允许包装 `UnsafeCell` 的类型也实现 `DispatchFromDyn` 并成为对象安全方法接收器。
//
// 请注意,目前 `UnsafeCell` 本身不能是方法接管者,因为它没有实现 Deref。
// 换句话说:
// `self: UnsafeCell<&Self>` 行不通 `self: UnsafeCellWrapper<Self>` 成为可能
//
//
#[unstable(feature = "dispatch_from_dyn", issue = "none")]
impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<UnsafeCell<U>> for UnsafeCell<T> {}

/// [`UnsafeCell`],但是 [`Sync`]。
///
/// 这只是一个 `UnsafeCell`,但如果 `T` 实现了 `Sync`,则它也就实现了 `Sync`。
///
/// `UnsafeCell` 没有实现 `Sync`,以防止意外误用。
/// 如果有意的话,您可以使用 `SyncUnsafeCell` 而不是 `UnsafeCell` 来允许它在线程之间共享。
///
/// 提供适当的同步仍然是用户的任务,因此使用这种类型同样不安全。
///
/// 有关详细信息,请参见 [`UnsafeCell`]。
///
///
#[unstable(feature = "sync_unsafe_cell", issue = "95439")]
#[repr(transparent)]
pub struct SyncUnsafeCell<T: ?Sized> {
    value: UnsafeCell<T>,
}

#[unstable(feature = "sync_unsafe_cell", issue = "95439")]
unsafe impl<T: ?Sized + Sync> Sync for SyncUnsafeCell<T> {}

#[unstable(feature = "sync_unsafe_cell", issue = "95439")]
impl<T> SyncUnsafeCell<T> {
    /// 创建一个新的 `SyncUnsafeCell` 实例,它将包装指定的值。
    #[inline]
    pub const fn new(value: T) -> Self {
        Self { value: UnsafeCell { value } }
    }

    /// 解开值,消耗 cell。
    #[inline]
    pub const fn into_inner(self) -> T {
        self.value.into_inner()
    }
}

#[unstable(feature = "sync_unsafe_cell", issue = "95439")]
impl<T: ?Sized> SyncUnsafeCell<T> {
    /// 获取指向包装值的可变指针。
    ///
    /// 可以将其强制转换为任何类型的指针。
    /// 强制转换为 `&mut T` 时,访问是唯一的 (无活跃的引用,可变或不活动),并确保转换为 `&T` 时没有发生任何可变的或可变别名。
    ///
    ///
    #[inline]
    pub const fn get(&self) -> *mut T {
        self.value.get()
    }

    /// 返回对底层数据的可变引用。
    ///
    /// 这个调用(在编译时)可变地借用了 `SyncUnsafeCell`,这保证了我们拥有唯一的引用。
    ///
    #[inline]
    pub const fn get_mut(&mut self) -> &mut T {
        self.value.get_mut()
    }

    /// 获取指向包装值的可变指针。
    ///
    /// 有关详细信息,请参见 [`UnsafeCell::get`]。
    #[inline]
    pub const fn raw_get(this: *const Self) -> *mut T {
        // 由于 SyncUnsafeCell 和 UnsafeCell 上都存在 #[repr(transparent)],所以我们可以将指针从 `SyncUnsafeCell<T>` 转换为 `T`。
        //
        // 请参见 UnsafeCell::raw_get。
        this as *const T as *mut T
    }
}

#[unstable(feature = "sync_unsafe_cell", issue = "95439")]
impl<T: Default> Default for SyncUnsafeCell<T> {
    /// 使用 T 的 `Default` 值创建一个 `SyncUnsafeCell`。
    fn default() -> SyncUnsafeCell<T> {
        SyncUnsafeCell::new(Default::default())
    }
}

#[unstable(feature = "sync_unsafe_cell", issue = "95439")]
impl<T> From<T> for SyncUnsafeCell<T> {
    /// 创建一个包含给定值的新 `SyncUnsafeCell<T>`。
    fn from(t: T) -> SyncUnsafeCell<T> {
        SyncUnsafeCell::new(t)
    }
}

#[unstable(feature = "coerce_unsized", issue = "18598")]
// #[unstable(feature = "sync_unsafe_cell", issue = "95439")]
impl<T: CoerceUnsized<U>, U> CoerceUnsized<SyncUnsafeCell<U>> for SyncUnsafeCell<T> {}

// 允许包装 `SyncUnsafeCell` 的类型也实现 `DispatchFromDyn` 并成为对象安全方法接收器。
//
// 请注意,目前 `SyncUnsafeCell` 本身不能是方法接管者,因为它没有实现 Deref。
// 换句话说:
// `self: SyncUnsafeCell<&Self>` 行不通 `self: SyncUnsafeCellWrapper<Self>` 成为可能
//
//
#[unstable(feature = "dispatch_from_dyn", issue = "none")]
// #[unstable(feature = "sync_unsafe_cell", issue = "95439")]
impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<SyncUnsafeCell<U>> for SyncUnsafeCell<T> {}

#[allow(unused)]
fn assert_coerce_unsized(
    a: UnsafeCell<&i32>,
    b: SyncUnsafeCell<&i32>,
    c: Cell<&i32>,
    d: RefCell<&i32>,
) {
    let _: UnsafeCell<&dyn Send> = a;
    let _: SyncUnsafeCell<&dyn Send> = b;
    let _: Cell<&dyn Send> = c;
    let _: RefCell<&dyn Send> = d;
}