Is the way an OS schedule threads related to parallel computing?
There is a relationship between what Wikipedia is calling "preemptive multitasking" and running multiple threads in parallel, but it's somewhat indirect.

Suppose you have two threads of computation that are independent (the memory locations they touch are non-overlapping).  Then we say that those two threads can run concurrently.  "Preemptive multitasking" is a way of giving the illusion that the threads are running concurrently, even though we only have a single physical processor.  The single processor gets interrupted (usually by some timer hardware) every once in a while (e.g., 100 times a second), and chooses which thread to run.  Since the processor is switching back and forth so quickly it is hard to tell that you aren't running simultaneously on two (slow) processors.

If you actually run the two threads on two different processors then you are really running in parallel, and there is no switching back and forth to share a single resource.

The similarity comes up because in both true parallelism and preemptive multitasking any ordering of the instructions between the two threads is possible.  Thus if there is any sharing of resources, memory, or locks you need to reason about the correctness of that sharing by proving that nothing bad can happen in any possible interleaving.

With cooperative multithreading you break the illusion of having multiple processors.  If a thread gets scheduled it runs as long as it wants to (and knows that the other thread is not running) and only gives up the processor by calling some system call (often called something like yield().)  On the one hand, you've lost the illusion of two processors, which is problematic if one of the threads forgets to yield().  The advantage is that you know when the the threads are switching back and forth, so the number of possible interleavings you need to reason about is much smaller.