time-slicing | long tasks into smaller tasks

Coroutines are scheduled cooperatively, not pre-emptively, so context switch is possible only at suspension points. This is actually by design, it makes execution much faster, because coroutines don't fight each other and the number of context switches is lower than in pre-emptive scheduling.

But as you noticed, it has drawbacks. If performing long CPU-intensive calculations it is advised to invoke yield() from time to time. It allows to free the thread for other coroutines. Another solution is to create a distinct thread pool for our calculations to separate them from other parts of the application. This has similar drawback as pre-emptive scheduling - it will make coroutines/threads fight for the access to CPU cores.

I can't replicate how you've made that pandas Dataframe from the code you've provided. But say I have a dummy dataframe:

Your program is indeed running in parallel execution. In this particular example however you don't need locks in your code, it would run perfectly well without them.

Now I make thread 1 work with task 1 and thread 2 work with task 2. This is bad because i would get famous time-slicing.

There's not necessarily anything bad about it; it allows the computer to make progress on both tasks at once, which is often what you want.

What is the price I am paying for introducing it?

The price is that your OS's scheduler will have to do a context-switch every so-many milliseconds -- which isn't usually a big deal since the scheduler's quantum (i.e. the amount of time it lets pass before switching from executing one thread to the other) is tuned to be long enough that the overhead of doing a context-switch is negligible.

The other price is that with two tasks in progress at the same time, the computer must keep both tasks' data in RAM at the same time, meaning a higher maximum RAM usage than in the one-task-at-a-time case. Whether that is significant or not depends on how much RAM your two tasks use. Switching back and forth between two data sets might also reduce the effectiveness of the CPU's caches somewhat, if one task's working-set would largely fit into the cache space available but both tasks' working-sets would not.

What does time-slicing need to do to switch from thread 1 to thread 2 and opposite?

To do a context switch, the OS's scheduler has to react to a timer-interrupt (that causes the scheduler-routine to run), save the current values of all of the CPU-core's registers into a RAM buffer, then load the other thread's register-values from (the RAM buffer where they were previously saved) back into the CPU-core's registers, and then set an interrupt-timer for the next time the scheduler will need to run.

Fork join framework does not replace the original low level thread API; it makes it easier to use for certain classes of problems.

The original, low-level thread API works: you can use all the CPUs and all the cores on the CPUs installed on the system. If you ever try to actually write multithreaded applications, you'll quickly realize that it is hard.

The low level thread API works well for problems where threads are largely independent, and don't have to share information between each other - in other words, embarrassingly parallel problems. Many problems however are not like this. With the low level API, it is very difficult to implement complex algorithms in a way that is safe (produces correct results and does not have unwanted effects like dead lock) and efficient (does not waste system resources).

The Java fork/join framework, an implementation on the fork/join model, was created as a high level mechanism to make it easier to apply parallel computing for divide and conquer algorithms.