It's an example of a concurrency control problem. It was originally posed by Dijkstra. Here's how it works:

Five (or n) philosophers are seated around a round table. In front of each philosopher is a bowl of spaghetti (or rice). Between each pair of bowls is a single fork (or chopstick). (5 single fork/chopsticks in all)1. Now, philosophers do one of two things; think, and eat. While thinking, philosopher does not interact with the system. From time to time a philosopher becomes hungry. To eat, she tries to pick up the two closest chopsticks (one from either side of the bowl). Chopsticks may be picked up one at a time, and a chopstick cannot be taken if a neighboring philosopher is using it. If a philosopher successfully gains both chopsticks, she eats until not hungry, without relinquishing the chopstick. Satiated, she then puts down each chopstick and resumes thinking.

The problem is that this situation can lead to deadlock. Imagine that all the philosophers become hungry simultaneously. Each reaches out and takes the chopstick on the left. Now, each reaches for the chopstick on the right. But it's in use! If the philosophers have no way of determining who should yield, they will starve.

Solutions to the problem must ensure not only that this can never occur, but that a situation does not arise in which any specific philosopher can never get the chopsticks (and hence starves, this is a true starvation problem instead of deadlock.)

This represents a set of computer science problems in which a finite set of resources is being shared by users (people, programs, etc) who need to amass a subset of those resources to perform work.

1. For simplicity, we'll use rice & chopsticks from here on.