A microcontroller does a series of steps -- usually one at a time -- to complete some task. An FPGA is just a way to wire up logic circuits that "do something".
Consider a simple example. Suppose we are working on, say, a rocket engine. We need to monitor 32 sensors and decide if any of two of them are out of limit. If they are we need to assert a shutdown as fast as we can.
There are ways you could design this with a microcontroller, but for illustration's sake I'm going to make it as hard as I can
Suppose each sensor is a 12 bit A/D that you read via a parallel register scheme.
A typical microcontroller would do this:
1) Read sensor #1
2) Test the limit
3) If limit exceeded twice set output
4) Repeat for sensor #2 (and so on)
So it is going to take 96 high-level steps to do the job and each step is probably several machine instructions. So if the CPU has a cycle time of 1uS, you are probably still in the millisecond range for all the sensors to be checked. What's more if sensor #1 and sensor #32 are out of limit, it could be a whole mS before you figure that out (assuming you found #1 out of bounds first).
For many tasks that might be good enough. But what if our design called for detecting faults within 5uS? Well you could speed up the processor, but you have to speed it up A LOT because the cycle speed is only 1/1000 or so of the total loop time.
Another option would be to use an FPGA. Assuming enough I/O, each A/D could get a dedicated port. It would be easy to detect any two faults and then the timing would depend on the FPGA's gate delay which is very small times the length of the longest logic path which is very small. It would be very easy to meet the strictest timing requirements with such a system.
Now, the modern thing to do is to have a CPU with an FPGA (or design a CPU using logic and program it into the FPGA). So, for example, if I were really doing this, I might put a simple CPU on the FPGA and then my "logic" part would just read the A/D, test the limit, and set a 32-bit word with the status that the onboard CPU could read. Since the CPU is just some FPGA gates, I could add a custom instruction that would look for more than one bit being set in a 32-bit word. So now I'd have a very small fast program that I could easily change (to set 2 outputs, for example, or maybe require the 2 faults to stay set for a certain length of time, etc.). But I'd have "hardware assist" to make my timing requirements.
This isn't much different from, say, a PIC where the CPU gets help from things like timers, A/D, PWM generators, etc. except with the FPGA you design and install the helper devices you need. Which, of course, is also more work for you, but you get what you want. One of the fundamental trades in life!
Oh yeah, I almost forgot. If you want some FPGA/CPLD tutorials (along with some CPU tutorials) you might enjoy http://tutor.al-williams.com