Thread-safe Lists Using Locks

class ThreadSafeList
{
private:
    struct node
    {
        std::mutex m;
        std::shared_ptr<int> data;
        std::unique_ptr<node> next;

        node() : next(nullptr) {}

        node(int const& value) : data(std::make_shared<int>(value)) {}
    };

    node head;

public:
    void push_front(int const& value)
    {
        std::unique_ptr<node> new_node(new node(value));
        std::lock_guard<std::mutex> lk(head.m);
        new_node->next = std::move(head.next);
        head.next = std::move(new_node);
    }

    template<typename Function>
    void for_each(Function f)
    {
        node* current = &head;
        std::unique_lock<std::mutex> lk(head.m);
        while (node* const next = current->next.get())
        {
            std::unique_lock<std::mutex> next_lk(next->m);
            lk.unlock();
            f(*next->data);
            current = next;
            lk = std::move(next_lk);
        }
    }

    template<typename Predicate>
    std::shared_ptr<int> find_first_if(Predicate p)
    {
        node* current = &head;
        std::unique_lock<std::mutex> lk(head.m);
        while (node* const next = current->next.get())
        {
            std::unique_lock<std::mutex> next_lk(next->m);
            lk.unlock();
            if (p(*next->data))
            {
                return next->data;
            }
            current = next;
            lk = std::move(next_lk);
        }
        return std::shared_ptr<int>();
    }

    template<typename Predicate>
    void remove_if(Predicate p)
    {
        node* current = &head;
        std::unique_lock<std::mutex> lk(head.m);
        while (node* const next = current->next.get())
        {
            std::unique_lock<std::mutex> next_lk(next->m);
            if (p(*next->data))
            {
                std::unique_ptr<node> old_next = std::move(current->next);
                current->next = std::move(next->next);
                next_lk.unlock();
            }
            else
            {
                lk.unlock();
                current = next;
                lk = std::move(next_lk);
            }
        }
    }
};

int main() {
    ThreadSafeList list;

    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back([&list, i] {
            list.push_front(i);
        });
    }

    for (int i = 0; i < 5; ++i) {
        threads.emplace_back([&list, i] {
            list.remove_if([i](int value) { return value == i; });
        });
    }

    for (int i = 0; i < 2; ++i) {
        threads.emplace_back([&list, i] {
            auto result = list.find_first_if([i](int value) { return value == i; });
            if (result) {
                std::cout << "Found: " << *result << std::endl;
            }
        });
    }

    for (int i = 0; i < 2; ++i) {
        threads.emplace_back([&list] {
            list.for_each([](int value) {
                std::cout << value << std::endl;
            });
        });
    }

    for (auto& t : threads) {
        t.join();
    }

    return 0;
}