Performance of C++ containers during thread execution - c++

Question

I am working on a project that uses multiple threads to parallelize tasks. During development, I noticed that performance of operations on a std::list container, e.g. pop_front() or push_back(), are significantly slower while executed in the thread, compared to single-thread execution. See the code snipped below:
#include <iostream>
#include <chrono>
#include <vector>
#include <string>
#include <thread>
#include <list>
using namespace std;
void SingleThreadedList()
{
auto t1 = std::chrono::high_resolution_clock::now();
for(int i=0; i<2; i++)
{
list<char> l;
for(int j=0; j<10000; j++)
{
l.push_back('c');
l.pop_front();
}
}
auto t2 = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count();
std::cout << "duration single thread: " << duration << endl;
}
void MultiThreadedList()
{
auto t1 = std::chrono::high_resolution_clock::now();
auto lambda_fkt = []() {
list<char> l;
for(int i=0; i<10000; i++)
{
l.push_back('c');
l.pop_front();
}
};
vector<thread*> thread_array;
for (int i=0; i<2; ++i)
{
thread *th = new thread(lambda_fkt);
thread_array.push_back(th);
}
for(auto t : thread_array)
{
t->join();
}
auto t2 = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count();
std::cout << "duration multi thread: " << duration << endl;
for(auto t : thread_array)
{
delete t;
}
}
int main() {
SingleThreadedList();
MultiThreadedList();
}
the code produces the following output:
duration single thread: 4589
duration multi thread: 245483
Single Thread variant takes 4 ms, but as soon as the threads are created, execution takes more than 200ms! I cannot imagine that standard library containers show such a performance difference, depending on the execution context. Therefore I wonder if maybe someone can explain to me, what happens in this code and how I can avoid the performance decrease within thread? Thank you!
PS: When I remove the list operations from this sample and add e.g. some simple math, the code quickly shows the expected behavior: Multi-thread variant gets faster, if the computation is split among multiple threads, thus using multiple cores to get the result.