Use of std::shared_mutex with shared_lock instead of native locks defined in ThreadGranularity.h about dataframe

[sierret]

I'm sorry. I did read the section and understand the gist of it but can't say I get every single detail. As you say multithreading is indeed pretty complex. Which is exactly why I decided to make post an issue. I suppose what I was basically asking was if the shared/regular mutexes were capable of protecting the static and internal data structures but didn't know how to phrase it. But thank you you answered my question.

[hosseinmoein]

First, read the multithreading section in the documentation.
There are two levels of protection you need.

1. You need to protect the DataFrame static and internal data structures that are hidden. For that, you must use my spin lock and call set_lock()
2. You also have to protect the DataFrame columns that are exposed to the user, if a single instance of DataFrame is accessed from multiple threads. For that you can use your own separate lock (or my spin lock). It is up to you.

In general, multithreading is not as straightforward as it may sound. It requires very careful analysis and especially repeated benchmarking and tweaking. Often it is counterproductive. It also differs from one platform to another, because it depends on a particular hardware.
If you are new to multithreaded programming, I suggest you start with a single thread and maybe use the async interfaces. Once it works correctly, you can convert it to multithreaded version and compare results and efficiency and repeatedly tweak it