Python IPC: Using Value for Shared Data

Inter-Process Communication (IPC) means sharing data or signals between two or more running processes. Since processes run separately in their own memory space, they cannot directly access each other’s variables. That’s why Python provides special tools for IPC.

One simple way to share data between processes in Python is using multiprocessing.Value. This lets you create a shared variable, like a number or a character, that multiple processes can read and change safely.

In this article, you will learn how to create shared Value objects, access their contents, and modify them across processes without conflicts. We will see how locking works automatically to keep the shared data consistent.

Creating and Using a Shared Value

To create a shared Value, you specify the data type (like 'i' for integer, 'd' for double, or 'c' for char) and give it an initial value. This Value object lives in shared memory, so multiple processes can access and modify it.

In the example below, two processes increment the same shared integer five times each. They use a lock provided by get_lock() to avoid race conditions—this means only one process changes the value at a time, keeping the data safe and consistent.

from multiprocessing import Process, Value
import time

def increment(shared_num):

    for _ in range(5):

        with shared_num.get_lock():       # Lock before modifying

            shared_num.value += 1         # Increment the shared value
            print(f"Incremented to {shared_num.value}")

        time.sleep(0.5)                   # Sleep to allow interleaving


if __name__ == "__main__":

    shared_num = Value('i', 0)            # Create shared integer with initial 0
    p1 = Process(target=increment, args=(shared_num,))
    p2 = Process(target=increment, args=(shared_num,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print(f"Final value: {shared_num.value}")

This example shows how both processes safely update the same shared number without overwriting each other’s changes thanks to the lock. The final value reflects all increments combined.

Different Data Types Supported by Value

The multiprocessing.Value supports various simple data types to share between processes. Common types include integers ('i'), floats or doubles ('d'), and characters ('c'). Each type corresponds to a format code similar to Python’s struct module.

In the example below, one process updates a shared float by adding 1.5, while another changes a shared character from 'A' to 'Z'. Note that characters are stored as bytes (b'A'), so decoding is needed to convert them back to strings for display.

from multiprocessing import Process, Value
import time

def update_float(shared_float):

    with shared_float.get_lock():           # Lock before changing float
        shared_float.value += 1.5
        print(f"Updated float to {shared_float.value}")


def update_char(shared_char):

    with shared_char.get_lock():            # Lock before changing char
        shared_char.value = b'Z'            # Assign byte for char
        print(f"Updated char to {shared_char.value.decode()}")


if __name__ == "__main__":

    shared_float = Value('d', 0.0)           # Shared float initialized to 0.0
    shared_char = Value('c', b'A')           # Shared char initialized to 'A'

    p1 = Process(target=update_float, args=(shared_float,))
    p2 = Process(target=update_char, args=(shared_char,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print(f"Final float: {shared_float.value}, Final char: {shared_char.value.decode()}")

This example demonstrates that Value works for different data types, and you must handle bytes carefully when working with characters. Using the lock ensures that each update happens safely without interference.

Table of Supported Data Types for Value

The multiprocessing.Value supports several data types using type codes, which specify the kind of data stored. Here is a table of common type codes you can use when creating a Value:

For example, to create a shared integer, use 'i', and for a shared double-precision float, use 'd'. Characters require bytes (e.g., b'A'), and booleans are stored as signed chars ('b').

Here’s how to create a Value for each type from the table:

from multiprocessing import Value

# Signed integer
val_i = Value('i', 10)

# Unsigned integer
val_I = Value('I', 20)

# Float (single precision)
val_f = Value('f', 3.14)

# Double (double precision)
val_d = Value('d', 2.71828)

# Char (single byte)
val_c = Value('c', b'A')

# Signed char (often used as bool)
val_b = Value('b', True)

# Unsigned char
val_B = Value('B', 255)

# Signed short
val_h = Value('h', -1000)

# Unsigned short
val_H = Value('H', 65000)

# Signed long
val_l = Value('l', -100000)

# Unsigned long
val_L = Value('L', 100000)

# Signed long long (64-bit)
val_q = Value('q', -123456789012345)

# Unsigned long long (64-bit)
val_Q = Value('Q', 123456789012345)

Each Value holds a shared variable of the given type and initial value. These codes correspond to those used in Python’s built-in ctypes and the struct module, enabling a variety of simple data types to be shared easily across processes.

Using Locks to Synchronize Access

The Value object comes with an internal lock to ensure safe access when multiple processes read or write to the shared data. While you can use a with statement to handle locking automatically, sometimes you may want to manually acquire and release the lock for more control.

In the example below, each process increments the shared counter three times. Before changing the value, it explicitly acquires the lock to prevent other processes from modifying the value simultaneously. After the update, the lock is released, allowing other processes to access the value safely.

from multiprocessing import Process, Value

def safe_increment(shared_value):

    for _ in range(3):

        shared_value.get_lock().acquire()    # Acquire lock before update

        shared_value.value += 1               # Increment the shared value
        print(f"Value incremented to {shared_value.value}")

        shared_value.get_lock().release()    # Release lock after update


if __name__ == "__main__":

    counter = Value('i', 0)                   # Shared integer initialized to 0
    p1 = Process(target=safe_increment, args=(counter,))
    p2 = Process(target=safe_increment, args=(counter,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print(f"Counter final value: {counter.value}")

This example highlights the importance of locking when multiple processes modify the same shared value. Without locking, simultaneous updates could corrupt the data. By controlling access with the lock, the increments happen one at a time, preserving data integrity.

You can use the with statement to handle locking automatically, which makes your code cleaner and less error-prone. Here’s how you do it:

from multiprocessing import Process, Value
import time

def safe_increment(shared_value):

    for _ in range(3):

        with shared_value.get_lock():   # Automatically acquire and release lock
            shared_value.value += 1
            print(f"Value incremented to {shared_value.value}")

        time.sleep(0.1)  # Just to better observe the output


if __name__ == "__main__":

    counter = Value('i', 0)
    p1 = Process(target=safe_increment, args=(counter,))
    p2 = Process(target=safe_increment, args=(counter,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print(f"Counter final value: {counter.value}")

Using with ensures the lock is always released properly, even if something goes wrong inside the block. This is the recommended way to handle locks when working with shared values.

Sharing Boolean Flags with Value

Sometimes, processes need to coordinate by signaling a simple condition or state. The multiprocessing.Value object can be used to share a boolean flag between processes for this purpose. One process can wait for the flag to be set, while another sets it when a certain event happens.

In this example, the waiter process keeps checking the shared boolean flag inside a loop. It waits until the flag changes from False to True. The setter process sleeps for a moment, then safely updates the flag to True while holding the lock. This ensures the shared value is modified safely without conflicts.

from multiprocessing import Process, Value
import time

def waiter(flag):

    print("Waiting for flag...")

    while not flag.value:
        time.sleep(0.1)

    print("Flag detected, proceeding!")


def setter(flag):

    time.sleep(1)

    with flag.get_lock():
        flag.value = True
        print("Flag set to True!")


if __name__ == "__main__":

    flag = Value('b', False)  # 'b' = boolean

    p1 = Process(target=waiter, args=(flag,))
    p2 = Process(target=setter, args=(flag,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

Here, the waiter process continuously checks flag.value. It pauses in short sleeps to avoid busy waiting. When the setter process sets the flag to True, the waiter detects this change and continues execution.

This shows how a shared boolean value can be used as a simple signal or flag to coordinate actions between processes in Python. The locking mechanism included with Value ensures safe access, preventing race conditions during updates.

Practical Uses

Using multiprocessing.Value to share simple data between processes is very useful in many real-world situations. Here are some common examples of how shared values help coordinate work and share state:

Counters

Multiple processes can safely increment a shared counter to track how many tasks have been completed or how many items have been processed.

from multiprocessing import Process, Value

def worker(counter):

    for _ in range(5):

        with counter.get_lock():
            counter.value += 1
            print(f"Counter: {counter.value}")


if __name__ == "__main__":

    counter = Value('i', 0)

    processes = [Process(target=worker, args=(counter,)) for _ in range(3)]

    for p in processes:
        p.start()

    for p in processes:
        p.join()

    print(f"Final counter value: {counter.value}")

Boolean Flags

Processes can signal readiness or completion by setting a shared boolean flag, allowing other processes to wait or proceed.

from multiprocessing import Process, Value
import time

def wait_for_flag(flag):

    print("Waiting for flag...")

    while not flag.value:
        time.sleep(0.1)

    print("Flag detected!")


def set_flag(flag):

    time.sleep(1)

    with flag.get_lock():
        flag.value = True
        print("Flag set!")


if __name__ == "__main__":

    flag = Value('b', False)

    p1 = Process(target=wait_for_flag, args=(flag,))
    p2 = Process(target=set_flag, args=(flag,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

Shared State Values

Processes can share a numeric or character value that represents the current state of a system or process, updating it as tasks progress.

from multiprocessing import Process, Value
import time

def update_status(status):

    with status.get_lock():
        status.value = b'R'  # R for Running
        print(f"Status changed to: {status.value.decode()}")

    time.sleep(1)

    with status.get_lock():
        status.value = b'C'  # C for Completed
        print(f"Status changed to: {status.value.decode()}")


if __name__ == "__main__":

    status = Value('c', b'I')  # I for Idle
    p = Process(target=update_status, args=(status,))

    p.start()
    p.join()

    print(f"Final status: {status.value.decode()}")

These examples show how Value can be used to share and update simple data across processes, helping them communicate and coordinate effectively.

Conclusion

Value is a straightforward tool to share simple data like numbers, characters, or flags safely between multiple processes. It lets you create a shared variable that all processes can read and update, with built-in locking to avoid conflicts. Using Value, processes can coordinate through counters, boolean signals, or shared states.

Try these examples yourself with different data types and use cases. This will help you understand how processes can communicate and work together using shared data.