I have a decode function that decodes a string and internally uses a map to store already-decoded values for efficiency. This function is accessed by multiple threads (using pthread), so to prevent concurrent access issues with the map, I added a std::mutex. However, after adding the mutex, I noticed that some threads eventually stop working or appear to get stuck. When I removed the mutex locks, all threads ran without any issues.

My question is: Could this be a case of starvation? How can I resolve this?

Additional Context: This C++ code is being used in an Android application via JNI.

std::unordered_map<std::string, std::pair<int, std::vector<uint8_t>>> decoded_map;
std::mutex decoded_map_mutex;

const char* decode(const char* encodedString) {
    std::string encoded(encodedString);
    std::string decoded;
    
    for (/* some condition */) {
        {
            std::lock_guard<std::mutex> lock(decoded_map_mutex);
            // Operation involving map search
            auto it = decoded_map.find(part);
            if (it != decoded_map.end()) {
                // Some processing
            }
        }
        // Additional processing
        {
            std::lock_guard<std::mutex> lock(decoded_map_mutex);
            decoded_map[part] = std::make_pair(index / 4, bytes);
        }
        
        decode += part;
    }

    return strdup(decoded.c_str());
}