FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
python-docs-id/builtins/threadsafety.po at 3.14 · python/python-docs-id · GitHub
python
python-docs-id
Repository navigation
Code
Issues
2
(2)
Pull requests
3
(3)
Actions
Wiki
Security and quality
Insights
Expand file tree
Breadcrumbs
python-docs-id
/
builtins
/
threadsafety.po
Copy path
More file actions
More file actions
Latest commit
History
History
History
696 lines (578 loc) · 20.8 KB
Breadcrumbs
python-docs-id
/
builtins
/
threadsafety.po
Copy path
File metadata and controls
696 lines (578 loc) · 20.8 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
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
#
SOME DESCRIPTIVE TITLE.
#
Copyright (C) 2001 Python Software Foundation
#
This file is distributed under the same license as the Python package.
#
FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#,
fuzzy
msgid ""
msgstr ""
"
Project-Id-Version
:
Python 3.15\n
"
"
Report-Msgid-Bugs-To
:
\n
"
"
POT-Creation-Date
:
2026-10-19 19:33+0000\n
"
"
PO-Revision-Date
:
2026-09-13 17:09+0000\n
"
"
Language-Team
:
Indonesian (https://app.transifex.com/python-doc/teams/5390/
"
"
id/)\n
"
"
MIME-Version
:
1.0\n
"
"
Content-Type
:
text/plain; charset=UTF-8\n
"
"
Content-Transfer-Encoding
:
8bit\n
"
"
Language
:
id\n
"
"
Plural-Forms
:
nplurals=1; plural=0;\n
"
msgid
"Thread Safety Guarantees"
msgstr
""
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
""
msgid
""
"For general guidance on writing thread-safe code in free-threaded Python, "
"see :ref:`freethreading-python-howto`."
msgstr
""
msgid
"Thread safety levels"
msgstr
""
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
""
msgid
"Incompatible"
msgstr
""
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
""
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
""
msgid
"Compatible"
msgstr
""
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
""
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
""
msgid
"Safe on distinct objects"
msgstr
""
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
""
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
""
msgid
"Safe on shared objects"
msgstr
""
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
""
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
""
msgid
"Atomic"
msgstr
""
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
""
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
""
msgid
"Thread safety for list objects"
msgstr
""
msgid
""
"Reading a single element from a :class:`list` is :term:`atomic <atomic "
"operation>`:"
msgstr
""
msgid
"lst[i] # list.__getitem__"
msgstr
""
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
""
msgid
""
"item in lst\n"
"lst.index(item)\n"
"lst.count(item)"
msgstr
""
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
""
msgid
""
"All other operations from here on block using the :term:`per-object lock`."
msgstr
""
msgid
""
"Writing a single item via ``lst[i] = x`` is safe to call from multiple "
"threads and will not corrupt the list."
msgstr
""
msgid
""
"The following operations return new objects and appear :term:`atomic <atomic "
"operation>` to other threads:"
msgstr
""
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
""
msgid
""
"The following methods that only operate on a single element with no shifting "
"required are :term:`atomic <atomic operation>`:"
msgstr
""
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
""
msgid
""
"The :meth:`~list.clear` method is also :term:`atomic <atomic operation>`. "
"Other threads cannot observe elements being removed."
msgstr
""
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
""
msgid
""
"The following operations may allow :term:`lock-free` operations to observe "
"intermediate states since they modify multiple elements in place:"
msgstr
""
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
""
msgid
""
"The :meth:`~list.remove` method may allow concurrent modifications since "
"element comparison may execute arbitrary Python code (via :meth:`~object."
"__eq__`)."
msgstr
""
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
""
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
""
msgid
""
"Operations that involve multiple accesses, as well as iteration, are never "
"atomic. For example:"
msgstr
""
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
""
msgid
""
"Consider external synchronization when sharing :class:`list` instances "
"across threads."
msgstr
""
msgid
"Thread safety for dict objects"
msgstr
""
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
""
msgid
""
"The following operations and functions are :term:`lock-free` and :term:"
"`atomic <atomic operation>`."
msgstr
""
msgid
""
"d[key] # dict.__getitem__\n"
"d.get(key) # dict.get\n"
"key in d # dict.__contains__\n"
"len(d) # dict.__len__"
msgstr
""
msgid
"All other operations from here on hold the :term:`per-object lock`."
msgstr
""
msgid
""
"Writing or removing a single item is safe to call from multiple threads and "
"will not corrupt the dictionary:"
msgstr
""
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
""
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
""
msgid
""
"The following operations return new objects and hold the :term:`per-object "
"lock` for the duration of the operation:"
msgstr
""
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
""
msgid
""
"The :meth:`~dict.clear` method holds the lock for its duration. Other "
"threads cannot observe elements being removed."
msgstr
""
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
""
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
""
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
""
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
""
msgid
""
"dict.fromkeys(a_dict) # locks both\n"
"dict.fromkeys(a_set) # locks both\n"
"dict.fromkeys(a_frozenset) # locks both"
msgstr
""
msgid
""
"When updating from a non-dict iterable, only the target dictionary is "
"locked. The iterable may be concurrently modified by another thread:"
msgstr
""
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
""
msgid
""
"Operations that involve multiple accesses, as well as iteration, are never "
"atomic:"
msgstr
""
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
""
msgid
""
"To avoid time-of-check to time-of-use (TOCTOU) issues, use atomic operations "
"or handle exceptions:"
msgstr
""
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
""
msgid
""
"To safely iterate over a dictionary that may be modified by another thread, "
"iterate over a copy:"
msgstr
""
msgid
""
"# Make a copy to iterate safely\n"
"for key, value in d.copy().items():\n"
" process(key)"
msgstr
""
msgid
""
"Consider external synchronization when sharing :class:`dict` instances "
"across threads."
msgstr
""
msgid
"Thread safety for set objects"
msgstr
""
msgid
""
"The :func:`len` function is lock-free and :term:`atomic <atomic operation>`."
msgstr
""
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
""
msgid
"elem in s # set.__contains__"
msgstr
""
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
""
msgid
"All other operations from here on hold the per-object lock."
msgstr
""
msgid
""
"Adding or removing a single element is safe to call from multiple threads "
"and will not corrupt the set:"
msgstr
""
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
""
msgid
""
"These operations also compare elements, so the same :meth:`~object.__eq__` "
"considerations as above apply."
msgstr
""
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
""
msgid
""
"The :meth:`~set.clear` method holds the lock for its duration. Other threads "
"cannot observe elements being removed."
msgstr
""
msgid
""
"The following operations only accept :class:`set` or :class:`frozenset` as "
"operands and always lock both objects:"
msgstr
""
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
""
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
""
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
""
msgid
""
":meth:`set.intersection` and :meth:`set.difference` always try to lock all "
"objects."
msgstr
""
msgid
":meth:`set.symmetric_difference` tries to lock both objects."
msgstr
""
msgid
""
"The update variants of the above methods also have some differences between "
"them:"
msgstr
""
msgid
""
":meth:`set.difference_update` and :meth:`set.intersection_update` try to "
"lock all objects one-by-one."
msgstr
""
msgid
""
":meth:`set.symmetric_difference_update` only locks the arguments if it is of "
"type :class:`set`, :class:`frozenset`, or :class:`dict`."
msgstr
""
msgid
"The following methods always try to lock both objects:"
msgstr
""
msgid
""
"s.isdisjoint(other) # both locked\n"
"s.issubset(other) # both locked\n"
"s.issuperset(other) # both locked"
msgstr
""
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
""
msgid
""
"Consider external synchronization when sharing :class:`set` instances across "
"threads. See :ref:`freethreading-python-howto` for more information."
msgstr
""
msgid
"Thread safety for bytearray objects"
msgstr
""
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
""
msgid
""
"ba + other # may observe concurrent writes\n"
"ba == other # may observe concurrent writes\n"
"ba < other # may observe concurrent writes"
msgstr
""
msgid
""
"Reading a single element or slice is safe to call from multiple threads:"
msgstr
""
msgid
""
"ba[i] # bytearray.__getitem__\n"
"ba[i:j] # slice"
msgstr
""
msgid
""
"The following operations are safe to call from multiple threads and will not "
"corrupt the bytearray:"
msgstr
""
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
""
msgid
""
"Slice assignment locks both objects when *values* is a :class:`bytearray`:"
msgstr
""
msgid
"ba[i:j] = other_bytearray # both locked"
msgstr
""
msgid
""
"The following operations return new objects and hold the per-object lock for "
"the duration:"
msgstr
""
msgid
""
"ba.copy() # returns a shallow copy\n"
"ba * n # repeat into new bytearray"
msgstr
""
msgid
"The membership test holds the lock for its duration:"
msgstr
""
msgid
"x in ba # bytearray.__contains__"
msgstr
""
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
""
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
""
msgid
""
"To safely iterate over a bytearray that may be modified by another thread, "
"iterate over a copy:"
msgstr
""
msgid
""
"# Make a copy to iterate safely\n"
"for byte in ba.copy():\n"
" process(byte)"
msgstr
""
msgid
""
"Consider external synchronization when sharing :class:`bytearray` instances "
"across threads. See :ref:`freethreading-python-howto` for more information."
msgstr
""
msgid
"Thread safety for memoryview objects"
msgstr
""
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
""
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
""
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
""
msgid
""
"For immutable objects like :class:`bytes`, concurrent reads through multiple "
"memoryviews are safe."
msgstr
""
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
""
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
""
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
""
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
""
Back
|
FazBrowse Home
|
New Git URL