The most common reasons for multithreading don't have to do with performance (responsiveness, which is different, is the number one reason, and simplifying code algorithms is another, though this requires work since synchronization concerns can actually
make the code more complex).
Other's mention blocking I/O as a reason to use more threads. The reasoning here is, generally, responsiveness (and code simplification) not performance. To illustrate, many network applications will allocate one thread per connection. This makes for a relatively
responsive application and is certainly one of the easiest ways to code this scenario. However, it doesn't scale well. Such applications that need to scale would instead use async I/O and a thread pool with a distinct number of threads (with the algorithm
you mention being a fair, though not perfect, algorithm to follow). Remember, every thread allocated must be managed by the scheduler, and the more threads there are the more work must be done. Also, synchronization requirements become a bottle neck with
more threads, because there's more contention on shared resources.
Remember, however, that algorithms like the one given are just rules of thumb. It doesn't take into consideration several factors that will effect the outcome:
1) Thread scheduling, which is platform specific and usually intentionally under specified.
2) Multi-tasking. Most platforms, and all that support threading that I'm aware of, are multi-tasking systems. In addition to your program there will be N other programs running each with their own set of threads, and all of them will be taking time on the
CPUs as the scheduler sees fit.
3) Specific algorithms. If most of the program will be I/O bound but there's a set of tasks that are CPU bound placing the CPU bound tasks in seperate threads can often increase the actual performance, not just the responsiveness, of the application, up to
a point (which is dependent on the scheduler and the total number of threads in all processes, and so isn't precisely in your control).