What is Atomic Operations in Python?

Question

I'm a beginner in Python. Now I read about Threading and I have some questions.

IMO Atomic Operations (AO) = the simplest operation. the simplest operation in dev is a = 1. But I did read the article (http://preshing.com/20130618/atomic-vs-non-atomic-operations/) and I got the impression that it did not the simplest operation\AO. The author told us this operation divided into two operations and this operation wasn't AO. That this operation was AO it had to have another type. But I must say he told about C/C++ and bytecode, I think the same in Python. How I understood this depend on a type and maybe compiler. BUT Python is dynamic types of language. It has no types.

And I decided to ask the community these questions:

1. What are Atomic Operations in Python?

2. Which operations are AO in Python?

If the simple operation isn't simple then I do not understand what is Atomic Operations.

Answer 1

I developed one package shared_atomic which perform way better than multiprocessing and multithreads lock/Rlock. The module can be used for atomic operations under multiple processes and multiple threads conditions.

Environment,

    LINUX/MacOSX
            CPython 3.0 - 3.11
            Pypy 3.0 - 3.9

    Windows
            CPython 3.0 - 3.11
            Pypy not supported

Included Datatypes:

        atomic_int
        atomic_uint
        atomic_float
        atomic_bool
        atomic_bytearray
        atomic_string
        atomic_set, package bitarray >= 2.4.0 is needed.
        atomic_list, package bitarray >= 2.4.0 is needed.

Requirement,

    LINUX/MacOSX

            the package requires libatomic installed on Linux platform
            cffi >= 1.0.0 <= 1.1.15 to compile through on Linux/MacOSX platform
            gcc >= 4.8 to include the atomic APIs.

    Windows

            cppyy >= 1.5.0 <=2.3.1
            only support single thread/multiple threads modes, multiprocessing mode is not supported on windows

Installation

    To install shared_atomic, use pip:

        pip install shared_atomic

Usage

    create function used by child processes, refer to UIntAPIs, IntAPIs, BytearrayAPIs, StringAPIs, SetAPIs, ListAPIs, in each process, you can create multiple threads.

            def process_run(a):

                def subthread_run(a):

                    a.array_sub_and_fetch(b'x0F')

                threadlist = []

                for t in range(5000):

                    threadlist.append(Thread(target=subthread_run, args=(a,)))

                for t in range(5000):

                    threadlist[t].start()

                for t in range(5000):

                    threadlist[t].join()

    create the shared bytearray

        a = atomic_bytearray(b'ab', length=7, paddingdirection='r', paddingbytes=b'012', mode='m')

    start processes/threads to utilize the shared bytearray

        processlist = []

        for p in range(2):

            processlist.append(Process(target=process_run, args=(a,)))

        for p in range(2):

            processlist[p].start()

        for p in range(2):

            processlist[p].join()

        assert a.value == int.to_bytes(27411031864108609,length=8,byteorder='big')

    Currently concurrent.futures.ProcessPoolExecutor and concurrent.futures.ThreadPoolExecutor cannot be used to start multiple executions ,for serialization problems

Sourcecode Repo:

https://github.com/irvinren/shared_atomic.git

https://gitee.com/irvinren/shared_atomic.git

For documentation, please go to:

https://shared-atomic.readthedocs.io/en/latest/ 

The project is licensed under GPL v3.0