Item Do not depend on the thread scheduler

1. The Role of the Thread Scheduler

The thread scheduler determines which threads can run and for how long. Scaling policies vary between operating systems. It is crucial not to depend on the scheduler's behavior to guarantee the correctness or performance of your program, as this compromises portability.

2. Strategies for Robust Programs: Thread Balancing

To create robust programs, keep a number of executable threads close to the number of available processors. This avoids overloading the scheduler and ensures consistent behavior. Although the total number of threads may be higher, waiting (non-runnable) threads do not significantly impact system load.

3. Techniques for Managing Threads: Avoiding Active Waiting and Scaling

Avoid hot waiting, where a thread constantly checks the state of a shared resource. This consumes processor resources unnecessarily. Decrease the number of executable threads by correctly sizing thread pools (as in the Executor Framework) and creating appropriately sized tasks – not so small that overhead prevails, not so large that parallelism is prevented.

4. Example of Bad Practice: Active Hope

The code below demonstrates active waiting:

public class SlowCountDownLatch {
    private int count;

    public SlowCountDownLatch(int count) {
        this.count = count;
    }

    public void await() {
        while (count > 0) {
            // Espera-ativa: desperdício de recursos do processador
        }
    }

    public void countDown() {
        if (count > 0) {
            count--;
        }
    }
}

This code consumes excessive resources. The solution is to use CountDownLatch, which uses efficient blocking mechanisms.

5. Avoiding Thread.yield()

The Thread.yield() method is inconsistent between different JVM implementations and does not provide a robust or portable solution to concurrency problems. Instead of using Thread.yield(), restructure the code to reduce the number of executable threads.

Incorrect example:

while (!condition) {
    Thread.yield(); // Incorreto: uso de Thread.yield()
}

6. Thread Priority Adjustment

Adjusting thread priorities is also not very portable, varying between operating systems and JVMs. Its use must be restricted to specific scenarios where the improvement in quality of service justifies the loss of portability, and never as a solution to structural problems.

7. Conclusions

Do not depend on the scheduler to correct or optimize your program's performance. Avoid the use of Thread.yield() and excessive priority adjustments. The best approach is to restructure your applications to maintain a balanced number of executable threads.

---

Example from the book:

The above is the detailed content of Item Do not depend on the thread scheduler. For more information, please follow other related articles on the PHP Chinese website!