Typeerror: cannot pickle ‘_thread.rlock’ object

If you are running a Python project, you may have encounter an error message that reads, “TypeError: cannot pickle ‘thread.rlock’ object“.

This error message is very common when you are using the Pickle module in Python.

In this article, we will discuss the reasons for this error message and how to solve it.

Why the error cannot pickle ‘_thread.rlock’ object occur?

The TypeError “cannot pickle ‘_thread.RLock’ object” typically occurs becuase when you are trying to serialize or pickle an object that consist of a threading.RLock object.

Here’s an example that can raise the TypeError: cannot pickle '_thread.RLock' object error:

import pickle
import threading

lock = threading.RLock()

# Trying to pickle the lock object


Traceback (most recent call last):
File “C:\Users\Dell\PycharmProjects\pythonProject\main.py”, line 7, in
TypeError: cannot pickle ‘_thread.RLock’ object

In this example, we are trying to pickle a RLock object from the threading module using the pickle.dumps() method.

However, this will raise a TypeError with the message “cannot pickle ‘_thread.RLock’ object”.

This error occurs because the RLock object is a thread synchronization primitive and it is associated with a low-level system thread.

These objects can’t be serialized and deserialized using the pickle module.

How to solve the typeerror: cannot pickle _thread.rlock object error?

The TypeError: Cannot pickle ‘_thread.RLock’ object error occurs when you try to pickle an object that consist of a _thread.RLock object.

This error usually appear when you are using the multiprocessing module in Python, which uses pickling to pass data between processes.

Here are some possible solutions to this error:

Solution 1: Avoid using _thread.RLock objects

You can avoid using an objects that consist of _thread.RLock objects in your code if possible.

You can try to refactor your code to use different locking structure such as threading.Lock.

Solution 2: Using the ‘dill’ Module

The ‘dill’ module is an extension of the Pickle module that can serialize more Python objects than the standard Pickle module.

To use the ‘dill’ module, you must first install it using pip package.

pip install dill

Once is already installed, you can use the ‘dill’ module to serialize and deserialize objects that cannot be pickled by the standard Pickle module, including the “_thread.rlock” object.

Here’s an example on how to use the ‘dill’ module to pickle and unpickle an object:

import threading

import dill

# create an RLock object
lock = threading.RLock()

# serialize the object using dill
serialized_lock = dill.dumps(lock)

# deserialize the object using dill
deserialized_lock = dill.loads(serialized_lock)

Solution 3: Creating a Custom Class

Another solution to fix this error is to create a custom class that mimics the behavior of the “_thread.rlock” object but can be pickled.

Here’s an example of how to create a custom class:

import threading

class PicklableRLock:
    def __init__(self):
        self._lock = threading.RLock()

    def acquire(self):

    def release(self):

    def __getstate__(self):
        return {}

    def __setstate__(self, state):

This custom class has the same methods as the “_thread.rlock” object but is picklable.

When pickling this custom class, the “getstate()” method returns an empty dictionary.

It will suggest that there is no additional state to be pickled.

The “setstate()” method initializes the object after deserialization.

Additional Resources

By exploring the following tutorial you can learned more about the others Python typeerror occur.


In conclusion, we’ve discuss why this error occur and also we provide three best solutions to solve the Typeerror: cannot pickle ‘_thread.rlock’ object.

By following the solutions in this article it will be able to prevent you for getting an error when you are running a Python project.


What is Pickle?

Pickle is a module in Python which is used to serialize and deserialize Python objects.

How Does Pickling Work?

The Pickle module works by serializing and de-serializing the Python object hierarchy.

What is “_thread.rlock” Object

The “_thread.rlock” object is a synchronization primitive in Python’s threading module. It is used to lock resources that are shared between threads.

Why is “_thread.rlock” Object Used?

The “_thread.rlock” object is used to prevent multiple threads from accessing the same resource simultaneously.

To make sure that only one thread can access the resource at a time, for preventing race conditions and data corruption.