Featured White Papers

• Measuring Risk to Improve Java Software Quality
• Do You Really Get Classloaders?
• Pragmatic Continuous Delivery with Jenkins, Nexus, and LiveRebel
• Your Next Java Web App: Less XML, No Long Restarts, Fewer Hassles
• Coding with JRebel, Java Forever Changed
• 2012 Developer Productivity Report: Java Tools, Tech, Devs, and Data

Sponsored Links

• Graph databases are 1000x faster than relational.

  Learn More!

• Career opportunities at Harman- Careers That'll Rock Your Socks Off.

  Learn More!

• Developer-friendly Java PDF libraries by Qoppa Software

  Live Demos

• Stop blaming your app! Diagnose Java performance issues.

  Free tool >

• UrbanCode: Go From Continuous Integration to
  Continuous Delivery

  Learn More!

Sponsored Links

Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs

Thread use in Java

Adapt your code to handle both green and native threads

By Java Q&a Experts, JavaWorld.com, 10/20/99

Can a programmer determine whether a program's code will use green threads or native threads?

No. Only the user can decide which thread package to use when running a Java program. What's more, once the program starts, it can't switch between green and native threads.

This means that you should write code that will run under green threads as well as it does under native threads. Native-thread code is relatively easy because it uses the operating system's thread-scheduling system, and most operating systems ensure that every thread gets a chance to run. High-priority threads run often, while low-priority threads rarely get their chance, but they all take turns.

Green threads, on the other hand, make no such guarantee. If a high-priority thread is running a loop of code that never sleep()s, yield()s, wait()s, or perform()s some blocking I/O function, then no other thread will ever execute. The only promise green threads make is that a high-priority thread will preempt a low-priority one. That means the burden of scheduling is on the programmer's shoulders. Code that takes responsibility for its own scheduling, though, will function well under both green and native threads -- and, as a bonus, should work well under the native threads of every operating system.

Taking responsibility for thread scheduling sounds difficult, but in practice most programs don't need to do much. Anytime a thread performs disk or network I/O, for instance, it gives other threads a chance to run.

Scheduling is more of a worry for programs with threads that run in tight loops or that spend significant amounts of time running mathematical computations with no I/O. In those cases, a simple call to Thread.yield() is enough to give other threads of the same priority a chance to run. To share the CPU with a lower-priority thread, a thread can call Thread.sleep() or, more precisely, call wait() on an object until the low-priority thread signals the end of its run by calling notify() on that object.

About the author