What does a processor actually do billions of times every second?

A processor doesn't think, exactly. It repeats one small routine, over and over, from the moment it boots until it shuts down: fetch an instruction, decode it, execute it. That three-step loop is called the instruction cycle, and it is, underneath everything, what a computer actually does.

Fetch means the processor looks at a register called the program counter, which holds the address of the next instruction, and pulls that instruction in from memory. Decode means the control unit figures out what the instruction is asking for and readies the right components, such as the arithmetic logic unit built from adders. Execute means those components actually carry it out: an addition happens, a value moves, a branch is taken. Only this last step is useful to you; the rest is overhead that makes it possible.

A clock drives the whole thing, ticking at a frequency measured in gigahertz. After each tick, the processor's internal signals need a moment to settle before the next tick arrives, or the result comes out wrong. In simple processors, each instruction's three steps run start to finish before the next instruction begins. Modern processors instead overlap them in a pipeline, starting the next instruction's fetch while the current one is still being decoded or executed, so an instruction can finish on almost every single clock tick instead of every three.

That overlap isn't free. If a program suddenly jumps somewhere else, like at an if statement, the pipeline may have to throw out instructions it already started on and begin again, a stall. Some processors run pipelines ten or even twenty stages deep to squeeze out more speed, accepting more of these stalls as the price. To avoid most of them, processors guess: a branch predictor bets on which way the jump will go and starts down that path early. Guess right and no time is lost. Guess wrong and the work is thrown away.