|
|
Featured White Papers
- Why choose an Open Source BPM?
- 10 FAQs on Business Process Management
- Best Practices for Getting Started with BPM
- Free Your Devs From The Pain Of Java Redeploys
- Increase Velocity 40% by Using JRebel
- What Developers Want: The End of Application Redeploys
- Developer Productivity Report: Java Tools, Tech, Devs, and Data
- Coding with JRebel: Java Forever Changed
- Utilizing Fast Testing to Transform Java Development
- 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
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
Java 101: Understanding Java threads, Part 4: Thread groups, volatility, and thread-local variables
Final concepts for improving Java application programming with Java threads
This month's Java 101 concludes the thread series by focusing on thread groups, volatility, thread-local variables, timers, and the ThreadDeath class.
Understanding Java threads - read the whole series
Thread groups
In a network server program, one thread waits for and accepts requests from client programs to execute, for example, database
transactions or complex calculations. The thread usually creates a new thread to handle the request. Depending on the request
volume, many different threads might be simultaneously present, complicating thread management. To simplify thread management,
programs organize their threads with thread groups—java.lang.ThreadGroup objects that group related threads' Thread (and Thread subclass) objects. For example, your program can use ThreadGroup to group all printing threads into one group.
Note: To keep the discussion simple, I refer to thread groups as if they organize threads. In reality, thread groups organize Thread (and Thread subclass) objects associated with threads.
Java requires every thread and every thread group—save the root thread group, system—to join some other thread group. That arrangement leads to a hierarchical thread-group structure, which the figure below
illustrates in an application context.
Figure 1. An application's hierarchical thread-group structure begins with a main thread group just below the system thread group
At the top of the figure's structure is the system thread group. The JVM-created system group organizes JVM threads that deal with object finalization and other system tasks, and serves as the root thread group
of an application's hierarchical thread-group structure. Just below system is the JVM-created main thread group, which is system's subthread group (subgroup, for short). main contains at least one thread—the JVM-created main thread that executes byte-code instructions in the main() method.
Below the main group reside the subgroup 1 and subgroup 2 subgroups, application-created subgroups (which the figure's application creates). Furthermore, subgroup 1 groups three application-created threads: thread 1, thread 2, and thread 3. In contrast, subgroup 2 groups one application-created thread: my thread.
Now that you know the basics, let's start creating thread groups.
Create thread groups and associate threads with those groups
The ThreadGroup class's SDK documentation reveals two constructors: ThreadGroup(String name) and ThreadGroup(ThreadGroup parent, String name). Both constructors create a thread group and give it a name, as the name parameter specifies. The constructors differ in their choice of what thread group serves as parent to the newly created thread
group. Each thread group, except system, must have a parent thread group. For ThreadGroup(String name), the parent is the thread group of the thread that calls ThreadGroup(String name). As an example, if the main thread calls ThreadGroup(String name), the newly created thread group has the main thread's group as its parent—main. For ThreadGroup(ThreadGroup parent, String name), the parent is the group that parent references. The following code shows how to use these constructors to create a pair of thread groups:
- Feedback
More from JavaWorld
Resources
- Download this article's source code and resource files.
- Read every article in the Understanding Java threads series (Jeff Friesen, JavaWorld.com, 2002):
- For a glossary specific to this article, homework, tips, and more, see the Java 101 study guide that accompanies this article.
- For more information about exceptions and the run() method, read "Handling Uncaught Exceptions" ( Glen McCluskey, Java Developer Connection, January 2001).
- The Programming Java Threads in the Real World series uses common programming scenarios to introduce readers to programming Java threads (Alan Holub, JavaWorld.com, 1998-2001):
- Part 1: A Java programmer's guide to threading architectures
- Part 2: The perils of race conditions, deadlock, and other threading problems
- Part 3: Roll-your-own mutexes and centralized lock management
- Part 4: Condition variables and counting semaphores—filling in a few chinks in Java's threading model)
- Part 5: Has Sun abandoned run anywhere? PlusThreads and Swing, timers, and getting around stop(), suspend(), and resume() deprecation)
- Part 6: The Observer pattern and mysteries of the AWTEventMulticaster
- Part 7: Singletons, critical sections, and reader/writer locks
- Part 8: Threads in an object-oriented world, thread pools, implementing socket accept loops