In an RTOS, the task state consists of a snapshot of all the processor registers, along with an individual heap and stack memory allocation for each task (process). A system timer ensures that each task can not run for longer than some maximum time interval. A process may relinquish control voluntarily if it has nothing to do. Task switching is performed by swapping processor registers and memory allocations. The RTOS manages multitasking mostly transparently, so that each task seems to be independent.
Your question does hinge on terminology a little. The meaning of your 3 terms might vary from place to place. In an RTOS, a "running" task is the one that is currently loaded in the processor registers. I think a "ready" task is one that is waiting its turn to be loaded. A "blocked" task is one that, when loaded, discovers that it can't continue processing, so relinquishes control to the next task via the scheduler. Note that in a sophisticated RTOS, there may be a HAL layer that interfaces with the RTOS directly. So a process might be blocked for I/O and the HAL would test whether it can continue or not, instead of the process code. Thus in a simple RTOS with no HAL, no processes can be excluded from the active list by the scheduler, since the blocking state is known only to the process, not the RTOS. In that case, the difference between "ready" and "blocked" is dependent on the conditions that the process encounters when it is "running".
In other words, with an RTOS (the embedded kind especially), the "running" state is determined by the OS, and the "ready" or "blocked" state is managed by the application code. "blocked" code is just code that will test and find nothing to do, and call a relinquish() function to pass control. "ready" is the same code when it tests and finds that there is work to do, then it will continue to run until it either blocks, or times out.
With cooperative multitasking, the task state is maintained in conventional variables, or if the need arises for a large number of states, state variables. Tasks are designed by the programmer, to always relinquish control before a maximum time interval has elapsed. The main task (i.e. the program) always has the same registers and memory allocation. There is usually no core support for it, the logic is embedded in the program.