A thread group represents a set of threads. In addition, a thread group may also contain other thread groups. Thread groups form a tree in which each thread group has a parent except for the initial thread group.<\/p>\n
A thread group is a collection of several related threads. A thread pool allows developers to process multiple Java threads simultaneously and is available in the java.lang package.Internally, a thread group can be thought of as a tree in which every thread has a parent, except for a parent thread that is not assigned to it.<\/p>\n
It should be noted that a thread belonging to one particular thread group is able to obtain information about the same thread group it belongs to, but has no information on its parent or any other thread group.<\/p>\n
Example code:<\/strong><\/p>\n Output:<\/strong> In Java, a thread always exists in any of the following states. These states are:<\/strong><\/p>\n New Output:<\/strong> void destroy() Destroys a thread groupint enumerate(Thread[] list) Copies each thread in the thread group to the specified array int enumerate(ThreadGroup[] list) Copies each active subgroup in the thread group to the specified array int enumerate.<\/p>\n Output:<\/strong> If recursion is true, calls this operation recursively int enumerate(threadgroup list[], boolean recursion) Copies each active subgroup in the thread group to the specified array.<\/p>\n If recursion is true, calls this operation recursively int getMaximumPriority() Returns the maximum priority of the thread group getName() Returns the name of the thread group groupThreadGroup getParent() Returns the parent of the thread group.<\/p>\n Output:<\/strong> Java thread pooling allows developers to process multiple Java threads simultaneously, which is available in Java. lang package. In theory, a thread group is a tree in which every thread has a parent, except for a parent thread that is not assigned to it. All Java threads are members of the thread pool. Thread groups are a mechanism for accumulating multiple threads in an object and manipulating them at once, instead of individually.<\/p>\n Complicatity:<\/strong> It’s a matter of thinking about how different threads are going to interact and coordinate with one another, which is what adds complexity to your code. If this is the case, it may be hard to decipher and debug your code<\/p>\n Resource overhead:<\/strong> System resources, e.g. memory or processing power, are needed to create and manage threads. This, in particular when you build a lot of threads, can have an effect on your program’s performance.<\/p>\n Race condition:<\/strong> when multiple threads attempt to access and modify a common set of data at the same time, race conditions can occur if it is not clear what their final state will be. To debug this could be hard to do, and it may result in unpredictable behavior within your program. A deadlock occurs when, in order to release the resource, two or more threads wait on one another and are prevented from leaving an infinite loop.<\/p>\n Scheduling:<\/strong> You don’t guarantee the order of threads that are scheduled, which can cause unexpected behavior in your program.<\/p>\n A set of threads is represented by a group of threads. A second group of fibers may also be included in the fiber group. A thread group forms a tree in which each thread group has a parent group except the initial thread group.<\/p>\n","protected":false},"excerpt":{"rendered":" A thread group represents a set of threads. In addition, a thread group may also contain other thread groups. Thread groups form a tree in which each thread group has a parent except for...<\/p>\n","protected":false},"author":1,"featured_media":89443,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[183],"tags":[5422,5423,5424,5425,5426],"class_list":["post-89378","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-thread-group","tag-java-thread-group-with-examples","tag-thread-group","tag-thread-group-in-java","tag-thread-group-in-java-with-examples"],"yoast_head":"\npublic class Techvidvan Test implements Runnable{\npublic void run()\n{\n }\n public static void main(String[] args) {\n ThreadGroupTest threadGroupTest = new ThreadGroupTest();\n ThreadGroup threadGroup = new ThreadGroup(\"Parent Thread Group\");\n Thread t1 = new Thread(threadGroup, threadGroupTest,\"T1\");\n t1.start();\n Thread t2 = new Thread(threadGroup, threadGroupTest,\"T2\");\n t2.start();\n Thread t3 = new Thread(threadGroup, threadGroupTest,\"T3\");\n t3.start();\nSystem.out.println(\"Thread Group Name: \"+threadGroup.getName());\n threadGroup.list();\n }\n}<\/pre>\n
\nCreating Thread-<\/strong>1
\nStarting Thread-<\/strong>1
\nCreating Thread-<\/strong>2
\nStarting Thread-<\/strong>2
\nRunning Thread-<\/strong>1
\nThread: Thread-<\/strong>1, 4
\nRunning Thread<\/strong>-2<\/p>\nLife Cycle Of Thread:<\/h3>\n
\nActive
\nBlocked \/ Waiting
\nTimed waiting
\nEnded<\/p>\nimport java.lang.*;\nclass NewThread extends Thread\n{\n NewThread(String threadname, ThreadGroup tgob)\n {\n super(tgob, threadname);\n start();\n }\npublic void run()\n {\n\n for (int i = 0; i < 1000; i++)\n {\n try\n {\n Thread.sleep(10);\n }\n catch (InterruptedException ex)\n {\n System.out.println(\"Exception encounterted\");\n }\n }\n System.out.println(Thread.currentThread().getName() +\n \" finished executing\");\n }\n}\npublic class ThreadGroupDemo\n{\n public static void main(String arg[]) throws InterruptedException\n {\n \/\/ creating the thread group\n ThreadGroup gfg = new ThreadGroup(\"gfg\");\n\n ThreadGroup gfg_child = new ThreadGroup(gfg, \"child\");\n\n NewThread t1 = new NewThread(\"one\", gfg);\n System.out.println(\"Starting one\");\n NewThread t2 = new NewThread(\"two\", gfg);\n System.out.println(\"Starting two\");\n\n \/\/ checking the number of active thread\n System.out.println(\"number of active thread group: \"\n + gfg.activeGroupCount());\n }\n}<\/pre>\n
\nThe state of thread t1 after spawning it –<\/strong> NEW
\nThe state of thread t1 after invoking the method start() on it –<\/strong> RUNNABLE
\nThe state of thread t2 after spawning it –<\/strong> NEW
\nthe state of thread t2 after calling the method start() on it –<\/strong> RUNNABLE
\nThe state of thread t1 while it invoked the method join() on thread t2 –<\/strong>TIMED_WAITING
\nThe state of thread t2 after invoking the method sleep() on it –<\/strong> TIMED_WAITING
\nThe state of thread t2 when it has completed its execution –<\/strong> TERMINATED<\/p>\nimport java.lang.*;\nclass NewThread extends Thread\n{\n NewThread(String threadname, ThreadGroup tgob)\n {\n super(tgob, threadname);\n start();\n }\npublic void run()\n {\n\n for (int i = 0; i < 10; i++)\n {\n try\n {\n Thread.sleep(10);\n }\n catch (InterruptedException ex)\n {\n System.out.println(\"Exception encounterted\");\n }\n }\n }\n}\npublic class ThreadGroupDemo\n{\n public static void main(String arg[]) throws InterruptedException,\n SecurityException\n {\n ThreadGroup gfg = new ThreadGroup(\"Parent thread\");\n\n ThreadGroup gfg_child = new ThreadGroup(gfg, \"child thread\");\n\n NewThread t1 = new NewThread(\"one\", gfg);\n System.out.println(\"Starting one\");\n NewThread t2 = new NewThread(\"two\", gfg);\n System.out.println(\"Starting two\");\n t1.join();\n t2.join();\n gfg_child.destroy();\n System.out.println(gfg_child.getName() + \" destroyed\");\n gfg.destroy();\n System.out.println(gfg.getName() + \" destroyed\");\n }\n}<\/pre>\n
\nStarting the first
\nStarting the second
\nthe first thread has finished executing
\nthe second thread has finished executing
\nthe child group is destroyed.
\nthe parent group is destroyed.<\/p>\nimport java.lang.*;\nclass NewThread extends Thread\n{\n NewThread(String threadname, ThreadGroup tgob)\n {\n super(tgob, threadname);\n start();\n }\npublic void run()\n {\n\n for (int i = 0; i < 10; i++)\n {\n try\n {\n Thread.sleep(10);\n }\n catch (InterruptedException ex)\n {\n System.out.println(\"Thread \" + Thread.currentThread().getName()\n + \" interrupted\");\n }\n }\n System.out.println(Thread.currentThread().getName() +\n \" finished executing\");\n }\n}\npublic class ThreadGroupDemo\n{\n public static void main(String arg[]) throws InterruptedException,\n SecurityException\n {\n ThreadGroup gfg = new ThreadGroup(\"Parent thread\");\n ThreadGroup gfg_child = new ThreadGroup(gfg, \"child thread\");\n\n NewThread t1 = new NewThread(\"one\", gfg);\n System.out.println(\"Starting \" + t1.getName());\n NewThread t2 = new NewThread(\"two\", gfg);\n System.out.println(\"Starting \" + t2.getName());\n gfg.interrupt();\n }\n}<\/pre>\n
\nStarting hello thread…
\nStarting goodbye thread…
\nHello
\nHello
\nHello
\nHello
\nHello
\nHello
\nGoodbye
\nGoodbye
\nGoodbye
\nGoodbye
\nGoodbye
\n…….<\/p>\nNeed For Java Thread Group:<\/h3>\n
Advantages:<\/h4>\n
\n
Disadvantages:<\/h4>\n
Conclusion<\/h3>\n