ThreadGroup crea un grupo de hilos. Ofrece una manera conveniente de administrar grupos de subprocesos como una unidad. Esto es particularmente valioso en situaciones en las que desea suspender y reanudar varios hilos relacionados.
- El grupo de subprocesos forma un árbol en el que cada grupo de subprocesos, excepto el grupo de subprocesos inicial, tiene un padre.
- Un subproceso puede acceder a la información sobre su propio grupo de subprocesos, pero no acceder a la información sobre el grupo de subprocesos principal de su grupo de subprocesos o cualquier otro grupo de subprocesos.
Constructores:
- public ThreadGroup(String name): Construye un nuevo grupo de subprocesos. El padre de este nuevo grupo es el grupo de subprocesos del subproceso que se está ejecutando actualmente.
Throws: SecurityException - if the current thread cannot create a thread in the specified thread group.
- public ThreadGroup (ThreadGroup parent, String name): crea un nuevo grupo de subprocesos. El padre de este nuevo grupo es el grupo de subprocesos especificado.
Throws: NullPointerException - if the thread group argument is null. SecurityException - if the current thread cannot create a thread in the specified thread group.
Métodos
- int activeCount(): este método devuelve el número de subprocesos en el grupo más cualquier grupo para el que este subproceso sea padre.
Syntax: public int activeCount() Returns: This method returns an estimate of the number of active threads in this thread group and in any other thread group that has this thread group as an ancestor. Exception: NA
// Java code illustrating activeCount() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
1000
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Exception encounterted"
);
}
}
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"parent thread group"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting one"
);
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting two"
);
// checking the number of active thread
System.out.println(
"number of active thread: "
+ gfg.activeCount());
}
}
Producción:
Starting one Starting two number of active thread: 2
- int activeGroupCount(): este método devuelve una estimación del número de grupos activos en este grupo de subprocesos.
Syntax: public int activeGroupCount(). Returns: Returns the number of groups for which the invoking thread is parent. Exception: NA.
// Java code illustrating activeGroupCount() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
1000
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Exception encounterted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"gfg"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting one"
);
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting two"
);
// checking the number of active thread
System.out.println(
"number of active thread group: "
+ gfg.activeGroupCount());
}
}
Producción:
Starting one Starting two number of active thread group: 2 one finished executing two finished executing
- void checkAccess(): hace que el administrador de seguridad verifique que el subproceso que invoca puede acceder y/o cambiar el grupo en el que se llama checkAccess() .
Syntax: final void checkAccess(). Returns: NA. Exception: NA.
// Java code illustrating checkAccess() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
1000
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Exception encounterted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting one"
);
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting two"
);
gfg.checkAccess();
System.out.println(gfg.getName() +
" has access"
);
gfg_child.checkAccess();
System.out.println(gfg_child.getName() +
" has access"
);
}
}
Producción:
Starting one Starting two Parent thread has access child thread has access one finished executing two finished executing
- void destroy(): Destruye el grupo de subprocesos y cualquier grupo secundario en el que se llame.
Syntax: public void destroy(). Returns: NA. Exception: IllegalThreadStateException - if the thread group is not empty or if the thread group has already been destroyed. SecurityException - if the current thread cannot modify this thread group.
// Java code illustrating destroy() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Exception encounterted"
);
}
}
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting one"
);
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting two"
);
// block until other thread is finished
t1.join();
t2.join();
// destroying child thread
gfg_child.destroy();
System.out.println(gfg_child.getName() +
" destroyed"
);
// destroying parent thread
gfg.destroy();
System.out.println(gfg.getName() +
" destroyed"
);
}
}
Producción:
Starting one Starting two child thread destroyed Parent thread destroyed
- int enumerar (Grupo de subprocesos []): el subproceso que comprende el grupo de subprocesos que invoca se coloca en la array del grupo.
Syntax: public int enumerate(Thread group[]). Returns: the number of threads put into the array. Exception: SecurityException - if the current thread does not have permission to enumerate this thread group.
// Java code illustrating enumerate() method.
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex) {
System.out.println(
"Exception encounterted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting one"
);
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting two"
);
// returns the number of threads put into the array
Thread[] group =
new
Thread[gfg.activeCount()];
int
count = gfg.enumerate(group);
for
(
int
i =
0
; i < count; i++)
{
System.out.println(
"Thread "
+ group[i].getName() +
" found"
);
}
}
}
Producción:
Starting one Starting two Thread one found Thread two found one finished executing two finished executing
- int enumerate(Thread[] group, boolean recurse): Los subprocesos que componen el grupo de subprocesos que invocan se colocan en la array de grupos. Si todo es verdadero , los subprocesos de todos los subgrupos del subproceso también se agrupan.
Syntax: public int enumerate(Thread[] list, boolean recurse). Returns: the number of threads placed into the array. Exception: SecurityException - if the current thread does not have permission to enumerate this thread group.
// Java code illustrating enumerate(Thread[] group, boolean recurse)
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Exception encounterted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting one"
);
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting two"
);
// returns the number of threads put into the array
Thread[] group =
new
Thread[gfg.activeCount()];
int
count = gfg.enumerate(group,
true
);
for
(
int
i =
0
; i < count; i++)
{
System.out.println(
"Thread "
+ group[i].getName() +
" found"
);
}
}
}
Producción:
Starting one Starting two Thread one found Thread two found one finished executing two finished executing
- int enumerate(ThreadGroup[] group): Los subgrupos del grupo de subprocesos evocadores se colocan en la array de grupos.
Syntax: public int enumerate(ThreadGroup[] group). Returns: the number of thread groups put into the array. Exception: SecurityException - if the current thread does not have permission to enumerate this thread group.
// Java code illustrating enumerate(ThreadGroup[] group) method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Exception encounterted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting one"
);
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting two"
);
// returns the number of threads put into the array
ThreadGroup[] group =
new
ThreadGroup[gfg.activeCount()];
int
count = gfg.enumerate(group);
for
(
int
i =
0
; i < count; i++)
{
System.out.println(
"ThreadGroup "
+ group[i].getName() +
" found"
);
}
}
}
Producción:
Starting one Starting two ThreadGroup child thread found two finished executing one finished executing
- int enumerate(ThreadGroup[] group, boolean all): los subgrupos del grupo de subprocesos que invocan se colocan en la array de grupos. Si todo es verdadero , todos los subgrupos de los subgrupos (y así sucesivamente) también se agrupan.
Syntax: public int enumerate(ThreadGroup[] group, boolean all) Returns: the number of thread groups put into the array. Exception: SecurityException - if the current thread does not have permission to enumerate this thread group.
// Java code illustrating enumerate(ThreadGroup[] group, boolean all)
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Exception encounterted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting one"
);
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting two"
);
// returns the number of threads put into the array
ThreadGroup[] group =
new
ThreadGroup[gfg.activeCount()];
int
count = gfg.enumerate(group,
true
);
for
(
int
i =
0
; i < count; i++)
{
System.out.println(
"ThreadGroup "
+ group[i].getName() +
" found"
);
}
}
}
Producción:
Starting one Starting two ThreadGroup child thread found two finished executing one finished executing
- int getMaxPriority(): Devuelve la configuración de prioridad máxima para el grupo.
Syntax: final int getMaxPriority(). Returns: the maximum priority that a thread in this thread group can have. Exception: NA.
// Java code illustrating getMaxPriority() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Exception encounterted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
// checking the maximum priority of parent thread
System.out.println(
"Maximum priority of ParentThreadGroup = "
+ gfg.getMaxPriority());
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting one"
);
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting two"
);
}
}
Producción:
Maximum priority of ParentThreadGroup = 10 Starting one Starting two two finished executing one finished executing
- String getName(): este método devuelve el nombre del grupo.
Syntax: final String getName(). Returns: the name of this thread group. Exception: NA.
// Java code illustrating getName() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Exception encounterted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting "
+ t1.getName());
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting "
+ t2.getName());
}
}
Producción:
Starting one Starting two two finished executing one finished executing
- ThreadGroup getParent(): devuelve un valor nulo si el objeto ThreadGroup que invoca no tiene padre. De lo contrario, devuelve el padre del objeto que invoca.
Syntax: final ThreadGroup getParent(). Returns: the parent of this thread group. The top-level thread group is the only thread group whose parent is null. Exception: SecurityException - if the current thread cannot modify this thread group.
// Java code illustrating getParent() method
import
java.lang.*;
class
NewThread
extends
Thread {
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++) {
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex) {
System.out.println(
"Exception encounterted"
);
}
}
System.out.println(Thread.currentThread().getName()
+
" finished executing"
);
}
}
public
class
ThreadGroupDemo {
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting "
+ t1.getName());
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting "
+ t2.getName());
// prints the parent ThreadGroup
// of both parent and child threads
System.out.println(
"ParentThreadGroup for "
+ gfg.getName() +
" is "
+ gfg.getParent().getName());
System.out.println(
"ParentThreadGroup for "
+ gfg_child.getName()
+
" is "
+ gfg_child.getParent().getName());
}
}
Producción:
Starting one Starting two ParentThreadGroup for Parent thread is main ParentThreadGroup for child thread is Parent thread one finished executing two finished executing
- void interrupt(): invoca los métodos interrupt() de todos los subprocesos del grupo.
Syntax: public final void interrupt(). Returns: NA. Exception: SecurityException - if the current thread is not allowed to access this thread group or any of the threads in the thread group.
// Java code illustrating interrupt() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Thread "
+ Thread.currentThread().getName()
+
" interrupted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting "
+ t1.getName());
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting "
+ t2.getName());
// interrupting thread group
gfg.interrupt();
}
}
Producción:
Starting one Starting two Thread two interrupted Thread one interrupted one finished executing two finished executing
- boolean isDaemon(): Comprueba si este grupo de subprocesos es un grupo de subprocesos daemon. Un grupo de subprocesos daemon se destruye automáticamente cuando se detiene su último subproceso o se destruye su último grupo de subprocesos.
Syntax: public final boolean isDaemon(). Returns: true if the group is daemon group. Otherwise it returns false. Exception: NA.
// Java code illustrating isDaemon() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Thread "
+ Thread.currentThread().getName()
+
" interrupted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting "
+ t1.getName());
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting "
+ t2.getName());
if
(gfg.isDaemon() ==
true
)
System.out.println(
"Group is Daemon group"
);
else
System.out.println(
"Group is not Daemon group"
);
}
}
Producción:
Starting one Starting two Group is not Daemon group two finished executing one finished executing
- boolean isDestroyed(): Este método prueba si este grupo de subprocesos ha sido destruido.
Syntax: public boolean isDestroyed(). Returns: true if this object is destroyed. Exception: NA.
// Java code illustrating isDestroyed() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Thread "
+ Thread.currentThread().getName()
+
" interrupted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException, Exception
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting "
+ t1.getName());
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting "
+ t2.getName());
if
(gfg.isDestroyed() ==
true
)
System.out.println(
"Group is destroyed"
);
else
System.out.println(
"Group is not destroyed"
);
}
}
Producción:
Starting one Starting two Group is not destroyed one finished executing two finished executing
- void list(): Muestra información sobre el grupo.
Syntax: public void list(). Returns: NA. Exception: NA.
// Java code illustrating list() method.
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Thread "
+ Thread.currentThread().getName()
+
" interrupted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException, Exception
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting "
+ t1.getName());
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting "
+ t2.getName());
// listing contents of parent ThreadGroup
System.out.println(
"\nListing parentThreadGroup: "
+ gfg.getName()
+
":"
);
// prints information about this thread group
// to the standard output
gfg.list();
}
}
Producción:
Starting one Starting two Listing parentThreadGroup: Parent thread: java.lang.ThreadGroup[name=Parent thread, maxpri=10] Thread[one, 5, Parent thread] Thread[two, 5, Parent thread] java.lang.ThreadGroup[name=child thread, maxpri=10] one finished executing two finished executing
- boolean parentOf(ThreadGroup group): este método prueba si este grupo de subprocesos es el argumento del grupo de subprocesos o uno de sus grupos de subprocesos antepasados.
Syntax: final boolean parentOf(ThreadGroup group). Returns: true if the invoking thread is the parent of group(or group itself). Otherwise, it returns false. Exception: NA.
// Java code illustrating parentOf() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Thread "
+ Thread.currentThread().getName()
+
" interrupted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException, Exception
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting "
+ t1.getName());
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting "
+ t2.getName());
// checking who is parent thread
if
(gfg.parentOf(gfg_child))
System.out.println(gfg.getName() +
" is parent of "
+
gfg_child.getName());
}
}
Producción:
Starting one Starting two Parent thread is parent of child thread two finished executing one finished executing
- void setDaemon(boolean isDaemon): este método cambia el estado del demonio de este grupo de subprocesos. Un grupo de subprocesos daemon se destruye automáticamente cuando se detiene su último subproceso o se destruye su último grupo de subprocesos.
Syntax: final void setDaemon(boolean isDaemon). Returns: If isDaemon is true, then the invoking group is flagged as a daemon group. Exception: SecurityException - if the current thread cannot modify this thread group.
// Java code illustrating setDaemon() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Thread "
+ Thread.currentThread().getName()
+
" interrupted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException, Exception
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
// daemon status is set to true
gfg.setDaemon(
true
);
// daemon status is set to true
gfg_child.setDaemon(
true
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting "
+ t1.getName());
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting "
+ t2.getName());
if
(gfg.isDaemon() && gfg_child.isDaemon())
System.out.println(
"Parent Thread group and "
+
"child thread group"
+
" is daemon"
);
}
}
Producción:
Starting one Starting two Parent Thread group and child thread group is daemon one finished executing two finished executing
- void setMaxPriority (prioridad int): establece la prioridad máxima del grupo invocador en prioridad.
Syntax: final void setMaxPriority(int priority). Returns: NA. Exception: SecurityException - if the current thread cannot modify this thread group.
// Java code illustrating setMaxPriority() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Thread "
+ Thread.currentThread().getName()
+
" interrupted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" [priority = "
+
Thread.currentThread().getPriority() + "]
finished executing.");
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException, Exception
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
gfg.setMaxPriority(Thread.MAX_PRIORITY -
2
);
gfg_child.setMaxPriority(Thread.NORM_PRIORITY);
NewThread t1 =
new
NewThread(
"one"
, gfg);
t1.setPriority(Thread.MAX_PRIORITY);
System.out.println(
"Starting "
+ t1.getName());
t1.start();
NewThread t2 =
new
NewThread(
"two"
, gfg_child);
t2.setPriority(Thread.MAX_PRIORITY);
System.out.println(
"Starting "
+ t2.getName());
t2.start();
}
}
Producción:
Starting one Starting two two [priority = 5] finished executing. one [priority = 8] finished executing.
- String toString(): este método devuelve una representación de string de este grupo de subprocesos.
Syntax: public String toString(). Returns: String equivalent of the group. Exception: SecurityException - if the current thread cannot modify this thread group.
// Java code illustrating toString() method
import
java.lang.*;
class
NewThread
extends
Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super
(tgob, threadname);
start();
}
public
void
run()
{
for
(
int
i =
0
; i <
10
; i++)
{
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException ex)
{
System.out.println(
"Thread "
+ Thread.currentThread().getName()
+
" interrupted"
);
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing"
);
}
}
public
class
ThreadGroupDemo
{
public
static
void
main(String arg[])
throws
InterruptedException,
SecurityException, Exception
{
// creating the thread group
ThreadGroup gfg =
new
ThreadGroup(
"Parent thread"
);
ThreadGroup gfg_child =
new
ThreadGroup(gfg,
"child thread"
);
// daemon status is set to true
gfg.setDaemon(
true
);
// daemon status is set to true
gfg_child.setDaemon(
true
);
NewThread t1 =
new
NewThread(
"one"
, gfg);
System.out.println(
"Starting "
+ t1.getName());
NewThread t2 =
new
NewThread(
"two"
, gfg);
System.out.println(
"Starting "
+ t2.getName());
// string equivalent of the parent group
System.out.println(
"String equivalent: "
+ gfg.toString());
}
}
Producción:
Starting one Starting two String equivalent: java.lang.ThreadGroup[name=Parent thread, maxpri=10] one finished executing two finished executing
Este artículo es una contribución de Abhishek Verma . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA