Repository navigation
Expand file tree
/
Copy paththreadsafety.po
More file actions
814 lines (696 loc) · 25.4 KB
/
Copy paththreadsafety.po
File metadata and controls
814 lines (696 loc) · 25.4 KB
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
# German translations for Python package.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# Automatically generated, 2026.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-12 03:18+0000\n"
"PO-Revision-Date: 2026-09-22 21:21+0200\n"
"Last-Translator: Automatically generated\n"
"Language-Team: none\n"
"Language: de\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
#: ../../builtins/threadsafety.rst:5
msgid "Thread Safety Guarantees"
msgstr ""
#: ../../builtins/threadsafety.rst:7
msgid ""
"This page documents thread-safety guarantees for built-in types in Python's "
"free-threaded build. The guarantees described here apply when using Python "
"with the :term:`GIL` disabled (free-threaded mode). When the GIL is enabled, "
"most operations are implicitly serialized."
msgstr ""
#: ../../builtins/threadsafety.rst:12
msgid ""
"For general guidance on writing thread-safe code in free-threaded Python, "
"see :ref:`freethreading-python-howto`."
msgstr ""
#: ../../builtins/threadsafety.rst:19
msgid "Thread safety levels"
msgstr ""
#: ../../builtins/threadsafety.rst:21
msgid ""
"The C API documentation uses the following levels to describe the thread "
"safety guarantees of each function. The levels are listed from least to most "
"safe."
msgstr ""
#: ../../builtins/threadsafety.rst:28
msgid "Incompatible"
msgstr ""
#: ../../builtins/threadsafety.rst:30
msgid ""
"A function or operation that cannot be made safe for concurrent use even "
"with external synchronization. Incompatible code typically accesses global "
"state in an unsynchronized way and must only be called from a single thread "
"throughout the program's lifetime."
msgstr ""
#: ../../builtins/threadsafety.rst:35
msgid ""
"Example: a function that modifies process-wide state such as signal handlers "
"or environment variables, where concurrent calls from any threads, even with "
"external locking, can conflict with the runtime or other libraries."
msgstr ""
#: ../../builtins/threadsafety.rst:42
msgid "Compatible"
msgstr ""
#: ../../builtins/threadsafety.rst:44
msgid ""
"A function or operation that is safe to call from multiple threads "
"*provided* the caller supplies appropriate external synchronization, for "
"example by holding a :term:`lock` for the duration of each call. Without "
"such synchronization, concurrent calls may produce :term:`race conditions "
"<race condition>` or :term:`data races <data race>`."
msgstr ""
#: ../../builtins/threadsafety.rst:50
msgid ""
"Example: a function that reads from or writes to an object whose internal "
"state is not protected by a lock. Callers must ensure that no two threads "
"access the same object at the same time."
msgstr ""
#: ../../builtins/threadsafety.rst:57
msgid "Safe on distinct objects"
msgstr ""
#: ../../builtins/threadsafety.rst:59
msgid ""
"A function or operation that is safe to call from multiple threads without "
"external synchronization, as long as each thread operates on a **different** "
"object. Two threads may call the function at the same time, but they must "
"not pass the same object (or objects that share underlying state) as "
"arguments."
msgstr ""
#: ../../builtins/threadsafety.rst:65
msgid ""
"Example: a function that modifies fields of a struct using non-atomic "
"writes. Two threads can each call the function on their own struct instance "
"safely, but concurrent calls on the *same* instance require external "
"synchronization."
msgstr ""
#: ../../builtins/threadsafety.rst:73
msgid "Safe on shared objects"
msgstr ""
#: ../../builtins/threadsafety.rst:75
msgid ""
"A function or operation that is safe for concurrent use on the **same** "
"object. The implementation uses internal synchronization (such as :term:`per-"
"object locks <per-object lock>` or :ref:`critical sections <python-critical-"
"section-api>`) to protect shared mutable state, so callers do not need to "
"supply their own locking."
msgstr ""
#: ../../builtins/threadsafety.rst:81
msgid ""
"Example: :c:func:`PyList_GetItemRef` can be called from multiple threads on "
"the same :c:type:`PyListObject` - it uses internal synchronization to "
"serialize access."
msgstr ""
#: ../../builtins/threadsafety.rst:88
msgid "Atomic"
msgstr ""
#: ../../builtins/threadsafety.rst:90
msgid ""
"A function or operation that appears :term:`atomic <atomic operation>` with "
"respect to other threads - it executes instantaneously from the perspective "
"of other threads. This is the strongest form of thread safety."
msgstr ""
#: ../../builtins/threadsafety.rst:94
msgid ""
"Example: :c:func:`PyMutex_IsLocked` performs an atomic read of the mutex "
"state and can be called from any thread at any time."
msgstr ""
#: ../../builtins/threadsafety.rst:101
msgid "Thread safety for list objects"
msgstr ""
#: ../../builtins/threadsafety.rst:103
msgid ""
"Reading a single element from a :class:`list` is :term:`atomic <atomic "
"operation>`:"
msgstr ""
#: ../../builtins/threadsafety.rst:106
msgid "lst[i] # list.__getitem__"
msgstr ""
#: ../../builtins/threadsafety.rst:111
msgid ""
"The following methods traverse the list and use :term:`atomic <atomic "
"operation>` reads of each item to perform their function. That means that "
"they may return results affected by concurrent modifications:"
msgstr ""
#: ../../builtins/threadsafety.rst:115
msgid ""
"item in lst\n"
"lst.index(item)\n"
"lst.count(item)"
msgstr ""
#: ../../builtins/threadsafety.rst:122
msgid ""
"All of the above operations avoid acquiring :term:`per-object locks <per-"
"object lock>`. They do not block concurrent modifications. Other operations "
"that hold a lock will not block these from observing intermediate states."
msgstr ""
#: ../../builtins/threadsafety.rst:127
msgid ""
"All other operations from here on block using the :term:`per-object lock`."
msgstr ""
#: ../../builtins/threadsafety.rst:129
msgid ""
"Writing a single item via ``lst[i] = x`` is safe to call from multiple "
"threads and will not corrupt the list."
msgstr ""
#: ../../builtins/threadsafety.rst:132
msgid ""
"The following operations return new objects and appear :term:`atomic <atomic "
"operation>` to other threads:"
msgstr ""
#: ../../builtins/threadsafety.rst:135
msgid ""
"lst1 + lst2 # concatenates two lists into a new list\n"
"x * lst # repeats lst x times into a new list\n"
"lst.copy() # returns a shallow copy of the list"
msgstr ""
#: ../../builtins/threadsafety.rst:142
msgid ""
"The following methods that only operate on a single element with no shifting "
"required are :term:`atomic <atomic operation>`:"
msgstr ""
#: ../../builtins/threadsafety.rst:145
msgid ""
"lst.append(x) # append to the end of the list, no shifting required\n"
"lst.pop() # pop element from the end of the list, no shifting required"
msgstr ""
#: ../../builtins/threadsafety.rst:151
msgid ""
"The :meth:`~list.clear` method is also :term:`atomic <atomic operation>`. "
"Other threads cannot observe elements being removed."
msgstr ""
#: ../../builtins/threadsafety.rst:154
msgid ""
"The :meth:`~list.sort` method is not :term:`atomic <atomic operation>`. "
"Other threads cannot observe intermediate states during sorting, but the "
"list appears empty for the duration of the sort."
msgstr ""
#: ../../builtins/threadsafety.rst:158
msgid ""
"The following operations may allow :term:`lock-free` operations to observe "
"intermediate states since they modify multiple elements in place:"
msgstr ""
#: ../../builtins/threadsafety.rst:161
msgid ""
"lst.insert(idx, item) # shifts elements\n"
"lst.pop(idx) # idx not at the end of the list, shifts elements\n"
"lst *= x # copies elements in place"
msgstr ""
#: ../../builtins/threadsafety.rst:168
msgid ""
"The :meth:`~list.remove` method may allow concurrent modifications since "
"element comparison may execute arbitrary Python code (via :meth:`~object."
"__eq__`)."
msgstr ""
#: ../../builtins/threadsafety.rst:172
msgid ""
":meth:`~list.extend` is safe to call from multiple threads. However, its "
"guarantees depend on the iterable passed to it. If it is a :class:`list`, a :"
"class:`tuple`, a :class:`set`, a :class:`frozenset`, a :class:`dict` or a :"
"ref:`dictionary view object <dict-views>` (but not their subclasses), the "
"``extend`` operation is safe from concurrent modifications to the iterable. "
"Otherwise, an iterator is created which can be concurrently modified by "
"another thread. The same applies to inplace concatenation of a list with "
"other iterables when using ``lst += iterable``."
msgstr ""
#: ../../builtins/threadsafety.rst:181
msgid ""
"Similarly, assigning to a list slice with ``lst[i:j] = iterable`` is safe to "
"call from multiple threads, but ``iterable`` is only locked when it is also "
"a :class:`list` (but not its subclasses)."
msgstr ""
#: ../../builtins/threadsafety.rst:185
msgid ""
"Operations that involve multiple accesses, as well as iteration, are never "
"atomic. For example:"
msgstr ""
#: ../../builtins/threadsafety.rst:188
msgid ""
"# NOT atomic: read-modify-write\n"
"lst[i] = lst[i] + 1\n"
"\n"
"# NOT atomic: check-then-act\n"
"if lst:\n"
" item = lst.pop()\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for item in lst:\n"
" process(item) # another thread may modify lst"
msgstr ""
#: ../../builtins/threadsafety.rst:202
msgid ""
"Consider external synchronization when sharing :class:`list` instances "
"across threads."
msgstr ""
#: ../../builtins/threadsafety.rst:209
msgid "Thread safety for dict objects"
msgstr ""
#: ../../builtins/threadsafety.rst:211
msgid ""
"Creating a dictionary with the :class:`dict` constructor is atomic when the "
"argument to it is a :class:`dict` or a :class:`tuple`. When using the :meth:"
"`dict.fromkeys` method, dictionary creation is atomic when the argument is "
"a :class:`dict`, :class:`tuple`, :class:`set` or :class:`frozenset`."
msgstr ""
#: ../../builtins/threadsafety.rst:217
msgid ""
"The following operations and functions are :term:`lock-free` and :term:"
"`atomic <atomic operation>`."
msgstr ""
#: ../../builtins/threadsafety.rst:220
msgid ""
"d[key] # dict.__getitem__\n"
"d.get(key) # dict.get\n"
"key in d # dict.__contains__\n"
"len(d) # dict.__len__"
msgstr ""
#: ../../builtins/threadsafety.rst:228
msgid "All other operations from here on hold the :term:`per-object lock`."
msgstr ""
#: ../../builtins/threadsafety.rst:230
msgid ""
"Writing or removing a single item is safe to call from multiple threads and "
"will not corrupt the dictionary:"
msgstr ""
#: ../../builtins/threadsafety.rst:233
msgid ""
"d[key] = value # write\n"
"del d[key] # delete\n"
"d.pop(key) # remove and return\n"
"d.popitem() # remove and return last item\n"
"d.setdefault(key, v) # insert if missing"
msgstr ""
#: ../../builtins/threadsafety.rst:242
msgid ""
"These operations may compare keys using :meth:`~object.__eq__`, which can "
"execute arbitrary Python code. During such comparisons, the dictionary may "
"be modified by another thread. For built-in types like :class:`str`, :class:"
"`int`, and :class:`float`, that implement :meth:`~object.__eq__` in C, the "
"underlying lock is not released during comparisons and this is not a concern."
msgstr ""
#: ../../builtins/threadsafety.rst:249
msgid ""
"The following operations return new objects and hold the :term:`per-object "
"lock` for the duration of the operation:"
msgstr ""
#: ../../builtins/threadsafety.rst:252
msgid ""
"d.copy() # returns a shallow copy of the dictionary\n"
"d | other # merges two dicts into a new dict\n"
"d.keys() # returns a new dict_keys view object\n"
"d.values() # returns a new dict_values view object\n"
"d.items() # returns a new dict_items view object"
msgstr ""
#: ../../builtins/threadsafety.rst:261
msgid ""
"The :meth:`~dict.clear` method holds the lock for its duration. Other "
"threads cannot observe elements being removed."
msgstr ""
#: ../../builtins/threadsafety.rst:264
msgid ""
"The following operations lock both dictionaries. For :meth:`~dict.update` "
"and ``|=``, this applies only when the other operand is a :class:`dict` that "
"uses the standard dict iterator (but not subclasses that override "
"iteration). For equality comparison, this applies to :class:`dict` and its "
"subclasses:"
msgstr ""
#: ../../builtins/threadsafety.rst:270
msgid ""
"d.update(other_dict) # both locked when other_dict is a dict\n"
"d |= other_dict # both locked when other_dict is a dict\n"
"d == other_dict # both locked for dict and subclasses"
msgstr ""
#: ../../builtins/threadsafety.rst:277
msgid ""
"All comparison operations also compare values using :meth:`~object.__eq__`, "
"so for non-built-in types the lock may be released during comparison."
msgstr ""
#: ../../builtins/threadsafety.rst:280
msgid ""
":meth:`~dict.fromkeys` locks both the new dictionary and the iterable when "
"the iterable is exactly a :class:`dict`, :class:`set`, or :class:`frozenset` "
"(not subclasses):"
msgstr ""
#: ../../builtins/threadsafety.rst:284
msgid ""
"dict.fromkeys(a_dict) # locks both\n"
"dict.fromkeys(a_set) # locks both\n"
"dict.fromkeys(a_frozenset) # locks both"
msgstr ""
#: ../../builtins/threadsafety.rst:291
msgid ""
"When updating from a non-dict iterable, only the target dictionary is "
"locked. The iterable may be concurrently modified by another thread:"
msgstr ""
#: ../../builtins/threadsafety.rst:294
msgid ""
"d.update(iterable) # iterable is not a dict: only d locked\n"
"d |= iterable # iterable is not a dict: only d locked\n"
"dict.fromkeys(iterable) # iterable is not a dict/set/frozenset: only "
"result locked"
msgstr ""
#: ../../builtins/threadsafety.rst:301 ../../builtins/threadsafety.rst:434
#: ../../builtins/threadsafety.rst:525
msgid ""
"Operations that involve multiple accesses, as well as iteration, are never "
"atomic:"
msgstr ""
#: ../../builtins/threadsafety.rst:304
msgid ""
"# NOT atomic: read-modify-write\n"
"d[key] = d[key] + 1\n"
"\n"
"# NOT atomic: check-then-act (TOCTOU)\n"
"if key in d:\n"
" del d[key]\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for key, value in d.items():\n"
" process(key) # another thread may modify d"
msgstr ""
#: ../../builtins/threadsafety.rst:318
msgid ""
"To avoid time-of-check to time-of-use (TOCTOU) issues, use atomic operations "
"or handle exceptions:"
msgstr ""
#: ../../builtins/threadsafety.rst:321
msgid ""
"# Use pop() with default instead of check-then-delete\n"
"d.pop(key, None)\n"
"\n"
"# Or handle the exception\n"
"try:\n"
" del d[key]\n"
"except KeyError:\n"
" pass"
msgstr ""
#: ../../builtins/threadsafety.rst:333
msgid ""
"To safely iterate over a dictionary that may be modified by another thread, "
"iterate over a copy:"
msgstr ""
#: ../../builtins/threadsafety.rst:336
msgid ""
"# Make a copy to iterate safely\n"
"for key, value in d.copy().items():\n"
" process(key)"
msgstr ""
#: ../../builtins/threadsafety.rst:343
msgid ""
"Consider external synchronization when sharing :class:`dict` instances "
"across threads."
msgstr ""
#: ../../builtins/threadsafety.rst:350
msgid "Thread safety for set objects"
msgstr ""
#: ../../builtins/threadsafety.rst:352 ../../builtins/threadsafety.rst:457
msgid ""
"The :func:`len` function is lock-free and :term:`atomic <atomic operation>`."
msgstr ""
#: ../../builtins/threadsafety.rst:354
msgid ""
"The following read operation is lock-free. It does not block concurrent "
"modifications and may observe intermediate states from operations that hold "
"the per-object lock:"
msgstr ""
#: ../../builtins/threadsafety.rst:358
msgid "elem in s # set.__contains__"
msgstr ""
#: ../../builtins/threadsafety.rst:363
msgid ""
"This operation may compare elements using :meth:`~object.__eq__`, which can "
"execute arbitrary Python code. During such comparisons, the set may be "
"modified by another thread. For built-in types like :class:`str`, :class:"
"`int`, and :class:`float`, :meth:`!__eq__` does not release the underlying "
"lock during comparisons and this is not a concern."
msgstr ""
#: ../../builtins/threadsafety.rst:369 ../../builtins/threadsafety.rst:470
msgid "All other operations from here on hold the per-object lock."
msgstr ""
#: ../../builtins/threadsafety.rst:371
msgid ""
"Adding or removing a single element is safe to call from multiple threads "
"and will not corrupt the set:"
msgstr ""
#: ../../builtins/threadsafety.rst:374
msgid ""
"s.add(elem) # add element\n"
"s.remove(elem) # remove element, raise if missing\n"
"s.discard(elem) # remove element if present\n"
"s.pop() # remove and return arbitrary element"
msgstr ""
#: ../../builtins/threadsafety.rst:382
msgid ""
"These operations also compare elements, so the same :meth:`~object.__eq__` "
"considerations as above apply."
msgstr ""
#: ../../builtins/threadsafety.rst:385
msgid ""
"The :meth:`~set.copy` method returns a new object and holds the per-object "
"lock for the duration so that it is always atomic."
msgstr ""
#: ../../builtins/threadsafety.rst:388
msgid ""
"The :meth:`~set.clear` method holds the lock for its duration. Other threads "
"cannot observe elements being removed."
msgstr ""
#: ../../builtins/threadsafety.rst:391
msgid ""
"The following operations only accept :class:`set` or :class:`frozenset` as "
"operands and always lock both objects:"
msgstr ""
#: ../../builtins/threadsafety.rst:394
msgid ""
"s |= other # other must be set/frozenset\n"
"s &= other # other must be set/frozenset\n"
"s -= other # other must be set/frozenset\n"
"s ^= other # other must be set/frozenset\n"
"s & other # other must be set/frozenset\n"
"s | other # other must be set/frozenset\n"
"s - other # other must be set/frozenset\n"
"s ^ other # other must be set/frozenset"
msgstr ""
#: ../../builtins/threadsafety.rst:406
msgid ""
":meth:`set.update`, :meth:`set.union`, :meth:`set.intersection` and :meth:"
"`set.difference` can take multiple iterables as arguments. They all iterate "
"through all the passed iterables and do the following:"
msgstr ""
#: ../../builtins/threadsafety.rst:410
msgid ""
":meth:`set.update` and :meth:`set.union` lock both objects only when the "
"other operand is a :class:`set`, :class:`frozenset`, or :class:`dict`."
msgstr ""
#: ../../builtins/threadsafety.rst:412
msgid ""
":meth:`set.intersection` and :meth:`set.difference` always try to lock all "
"objects."
msgstr ""
#: ../../builtins/threadsafety.rst:415
msgid ":meth:`set.symmetric_difference` tries to lock both objects."
msgstr ""
#: ../../builtins/threadsafety.rst:417
msgid ""
"The update variants of the above methods also have some differences between "
"them:"
msgstr ""
#: ../../builtins/threadsafety.rst:420
msgid ""
":meth:`set.difference_update` and :meth:`set.intersection_update` try to "
"lock all objects one-by-one."
msgstr ""
#: ../../builtins/threadsafety.rst:422
msgid ""
":meth:`set.symmetric_difference_update` only locks the arguments if it is of "
"type :class:`set`, :class:`frozenset`, or :class:`dict`."
msgstr ""
#: ../../builtins/threadsafety.rst:425
msgid "The following methods always try to lock both objects:"
msgstr ""
#: ../../builtins/threadsafety.rst:427
msgid ""
"s.isdisjoint(other) # both locked\n"
"s.issubset(other) # both locked\n"
"s.issuperset(other) # both locked"
msgstr ""
#: ../../builtins/threadsafety.rst:437
msgid ""
"# NOT atomic: check-then-act\n"
"if elem in s:\n"
" s.remove(elem)\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for elem in s:\n"
" process(elem) # another thread may modify s"
msgstr ""
#: ../../builtins/threadsafety.rst:448
msgid ""
"Consider external synchronization when sharing :class:`set` instances across "
"threads. See :ref:`freethreading-python-howto` for more information."
msgstr ""
#: ../../builtins/threadsafety.rst:455
msgid "Thread safety for bytearray objects"
msgstr ""
#: ../../builtins/threadsafety.rst:459
msgid ""
"Concatenation and comparisons use the buffer protocol, which prevents "
"resizing but does not hold the per-object lock. These operations may observe "
"intermediate states from concurrent modifications:"
msgstr ""
#: ../../builtins/threadsafety.rst:463
msgid ""
"ba + other # may observe concurrent writes\n"
"ba == other # may observe concurrent writes\n"
"ba < other # may observe concurrent writes"
msgstr ""
#: ../../builtins/threadsafety.rst:472
msgid ""
"Reading a single element or slice is safe to call from multiple threads:"
msgstr ""
#: ../../builtins/threadsafety.rst:474
msgid ""
"ba[i] # bytearray.__getitem__\n"
"ba[i:j] # slice"
msgstr ""
#: ../../builtins/threadsafety.rst:480
msgid ""
"The following operations are safe to call from multiple threads and will not "
"corrupt the bytearray:"
msgstr ""
#: ../../builtins/threadsafety.rst:483
msgid ""
"ba[i] = x # write single byte\n"
"ba[i:j] = values # write slice\n"
"ba.append(x) # append single byte\n"
"ba.extend(other) # extend with iterable\n"
"ba.insert(i, x) # insert single byte\n"
"ba.pop() # remove and return last byte\n"
"ba.pop(i) # remove and return byte at index\n"
"ba.remove(x) # remove first occurrence\n"
"ba.reverse() # reverse in place\n"
"ba.clear() # remove all bytes"
msgstr ""
#: ../../builtins/threadsafety.rst:497
msgid ""
"Slice assignment locks both objects when *values* is a :class:`bytearray`:"
msgstr ""
#: ../../builtins/threadsafety.rst:499
msgid "ba[i:j] = other_bytearray # both locked"
msgstr ""
#: ../../builtins/threadsafety.rst:504
msgid ""
"The following operations return new objects and hold the per-object lock for "
"the duration:"
msgstr ""
#: ../../builtins/threadsafety.rst:507
msgid ""
"ba.copy() # returns a shallow copy\n"
"ba * n # repeat into new bytearray"
msgstr ""
#: ../../builtins/threadsafety.rst:513
msgid "The membership test holds the lock for its duration:"
msgstr ""
#: ../../builtins/threadsafety.rst:515
msgid "x in ba # bytearray.__contains__"
msgstr ""
#: ../../builtins/threadsafety.rst:520
msgid ""
"All other bytearray methods (such as :meth:`~bytearray.find`, :meth:"
"`~bytearray.replace`, :meth:`~bytearray.split`, :meth:`~bytearray.decode`, "
"etc.) hold the per-object lock for their duration."
msgstr ""
#: ../../builtins/threadsafety.rst:528
msgid ""
"# NOT atomic: check-then-act\n"
"if x in ba:\n"
" ba.remove(x)\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for byte in ba:\n"
" process(byte) # another thread may modify ba"
msgstr ""
#: ../../builtins/threadsafety.rst:539
msgid ""
"To safely iterate over a bytearray that may be modified by another thread, "
"iterate over a copy:"
msgstr ""
#: ../../builtins/threadsafety.rst:542
msgid ""
"# Make a copy to iterate safely\n"
"for byte in ba.copy():\n"
" process(byte)"
msgstr ""
#: ../../builtins/threadsafety.rst:549
msgid ""
"Consider external synchronization when sharing :class:`bytearray` instances "
"across threads. See :ref:`freethreading-python-howto` for more information."
msgstr ""
#: ../../builtins/threadsafety.rst:556
msgid "Thread safety for memoryview objects"
msgstr ""
#: ../../builtins/threadsafety.rst:558
msgid ""
":class:`memoryview` objects provide access to the internal data of an "
"underlying object without copying. Thread safety depends on both the "
"memoryview itself and the underlying buffer exporter."
msgstr ""
#: ../../builtins/threadsafety.rst:562
msgid ""
"The memoryview implementation uses atomic operations to track its own "
"exports in the :term:`free-threaded build`. Creating and releasing a "
"memoryview are thread-safe. Attribute access (e.g., :attr:`~memoryview."
"shape`, :attr:`~memoryview.format`) reads fields that are immutable for the "
"lifetime of the memoryview, so concurrent reads are safe as long as the "
"memoryview has not been released."
msgstr ""
#: ../../builtins/threadsafety.rst:569
msgid ""
"However, the actual data accessed through the memoryview is owned by the "
"underlying object. Concurrent access to this data is only safe if the "
"underlying object supports it:"
msgstr ""
#: ../../builtins/threadsafety.rst:573
msgid ""
"For immutable objects like :class:`bytes`, concurrent reads through multiple "
"memoryviews are safe."
msgstr ""
#: ../../builtins/threadsafety.rst:576
msgid ""
"For mutable objects like :class:`bytearray`, reading and writing the same "
"memory region from multiple threads without external synchronization is not "
"safe and may result in data corruption. Note that even read-only memoryviews "
"of mutable objects do not prevent data races if the underlying object is "
"modified from another thread."
msgstr ""
#: ../../builtins/threadsafety.rst:583
msgid ""
"# NOT safe: concurrent writes to the same buffer\n"
"data = bytearray(1000)\n"
"view = memoryview(data)\n"
"# Thread 1: view[0:500] = b'x' * 500\n"
"# Thread 2: view[0:500] = b'y' * 500"
msgstr ""
#: ../../builtins/threadsafety.rst:592
msgid ""
"# Safe: use a lock for concurrent access\n"
"import threading\n"
"lock = threading.Lock()\n"
"data = bytearray(1000)\n"
"view = memoryview(data)\n"
"\n"
"with lock:\n"
" view[0:500] = b'x' * 500"
msgstr ""
#: ../../builtins/threadsafety.rst:604
msgid ""
"Resizing or reallocating the underlying object (such as calling :meth:"
"`bytearray.resize`) while a memoryview is exported raises :exc:"
"`BufferError`. This is enforced regardless of threading."
msgstr ""