If you want more information on this, check Wikipedias articles for "Multi-Core (Computing), but it is difficult to understand (and explain for that matter) since 2x2.2 = 4.4 but in terms of CPUs 2x2.2 != 4.4. I'm going to try and explain this as simply as possible, because what we have got so far is a bit muddled.
A program runs a series of threads on a CPU. A thread (which we'll call tasks since it makes it easier to understand) basically does a task for the program as a whole. For example, AppX might have 2 tasks: 1 to do "the actual work" and another to make the GUI (graphical user interface) still respond so the user doesn't think its crashed.
A multi-core CPU (like the Intel Core 2 Duo, or the AMD Athlon X2) is made up of cores. A dual-core CPU obviously has 2, a quad-core CPU has 4, etc. Roughly speaking (and without getting complex and going into hyperthreading and such) 1 core can run 1 thread at any given time. So a dual-core CPU can run 2 threads at the same time.
Understand? Good, because now it gets complicated.
As stated, AppX has 2 tasks; T1 (Task 1) does "the actual work" and T2 makes sure the GUI does something. Now on a dual-core CPU this works because T1 runs on C1 (Core 1) and T2 runs on C2 (Core 2). Remember that each core runs at 2.2GHz. Because the tasks are separate from each other yet part of the same program, each task runs at 2.2GHz but although we theoretically have 2 tasks at 2.2GHz, we do not have 4.4GHz. A program will run at 2.2GHz, but it will be able to do 2 things at the same time without slowing down.
This is advantageous if you run multi-threaded applications or several single-threaded applications at the same time. However, for things like games which usually are the only thing running and are not multi-threaded, it can reduce performance although total computing capacity is ≈ 2x. For this reason, games generally would run better on a 3GHz single core CPU than a 2GHz dual core CPU (having said that, games are becoming multi-threaded so this may not be true for long).
Remember, this is a simplified version of the concept, and it doesn't go into things like hyperthreading and system busses, so take it with a pinch of salt. It is a difficult concept to understand, but once you do understand you'll wonder why it was ever difficult.