Multithreading on a Single Core – How to Implement Efficiently

According to Wikipedia:

Parallel computing is a form of computation in which many calculations are carried out simultaneously, operating on the principle that large problems can often be divided into smaller ones, which are then solved concurrently ("in parallel").

That is, parallelism always implies concurrency.

Also, are multi-threaded programs running on multi-cores CPU but where the different threads are doing totally different computation considered to be using "parallelism"?

No. The essence of parallelism is that a large problem is divided into smaller ones so that the smaller pieces can be solved concurrently. The pieces are mutually independent (to some degree at least), but they're still part of the larger problem, which is now being solved in parallel.

The essence of concurrency is that a number of threads (or processes, or computers) are doing something simultaneously, possibly (but not necessarily) interacting in some ways. Wikipedia again:

Concurrency is a property of systems in which several computations are executing simultaneously, and potentially interacting with each other.

A process will have one thread, unless you tell it otherwise. Two processes then have two threads total. Each core on a processor can run one thread at a time. So, if you have a processor with 2 cores (or 2 processors with 1 core each):

• If you have one process with one thread, it will only ever run on one of the cores at a time (note that it can switch between cores, but will never use both at the same time).

• If you have two processes with one thread each, they can (but might not) both run at the same time (on different cores and/or different processors).

• If you have one process with two threads, both threads can (but might not) run at the same time (on different cores and/or different processors).