JAVAJava中的lang.Thread类-yiteyi-C++库

在程序中执行一行线程。每个程序可以有多个关联线程。每个线程都有一个优先级，线程调度程序使用该优先级来确定必须首先运行哪个线程。Java提供了一个线程类，该类具有各种方法调用，以便通过提供构造函数和方法来对线程执行操作来管理线程的行为。

null

图片[1]-JAVAJava中的lang.Thread类-yiteyi-C++库

创建线程的方法

创建扩展到父线程类的自己的类
实现可运行接口。

下面是一些伪代码，人们可以参考它们来更好地了解线程类。

图1：

JAVA

                         // Way 1                       
                         // Creating thread By Extending To Thread class                       
           
                         class                                     MyThread                                     extends                                     Thread {                       
           
                                                 // Method 1                       
                                                 // Run() method for our thread                       
                                                 public                                     void                                     run()                       
                                                 {                       
           
                                                 // Print statement                       
                                                 System.out.println(                       
                                                 "Thread is running created by extending to parent Thread class"                                     );                       
                                                 }                       
           
                                                 // Method 2                       
                                                 // Main driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
           
                                                 // Creating object of our thread class inside main()                       
                                                 // method                       
                                                 MyThread myThread =                                     new                                     MyThread();                       
                                   
                                                 // Starting the thread                       
                                                 myThread.start();                       
                                                 }                       
                         }                       

输出

Thread is running created by extending to parent Thread class

图2：

JAVA

                         // Way 2                       
                         // Creating thread using Runnable interface                       
           
                         class                                     ThreadUsingInterface                                     implements                                     Runnable {                       
           
                                                 // Method 1                       
                                                 // run() method for the thread                       
                                                 public                                     void                                     run()                       
                                                 {                       
           
                                                 // Print statement                       
                                                 System.out.println(                                     "Thread is created using Runnable interface"                                     );                       
                                                 }                       
           
                                                 // Method 2                       
                                                 // Main driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
           
                                                 // Creating object of our thread class inside main()                       
                                                 // method                       
                                                 ThreadUsingInterface obj =                                     new                                     ThreadUsingInterface();                       
                                   
                                                 // Passing the object to thread in main()                       
                                                 Thread myThread =                                     new                                     Thread(obj);                       
                                   
                                                 // Starting the thread                       
                                                 myThread.start();                       
                                                 }                       
                         }                       

输出

Thread is created using Runnable interface

Java中的线程类

线程是一个程序，它以类中经常使用的方法（）开始，该方法称为start（）方法。此方法查找run（）方法，该方法也是此类的一个方法，并开始执行run（）方法的bod。下面我们来关注一下sleep（）方法，稍后将讨论它。

注：每个用作线程的类都必须实现Runnable接口，并超越它的run方法。

语法：

public class Thread extends Object implements Runnable

此类构造函数如下所示：

建造师	执行的动作
线程（）	分配一个新的线程对象。
线程（可运行目标）	分配一个新的线程对象。
线程（可运行目标，字符串名称）	分配一个新的线程对象。
线程（字符串名）	分配一个新的线程对象。
线程（线程组，可运行目标）	分配一个新的线程对象。
线程（线程组、可运行目标、字符串名称）	分配一个新的线程对象，使其以目标对象为其运行对象，以指定的名称为其名称，并属于组引用的线程组。
线程（线程组、可运行目标、字符串名称、长堆栈大小）	分配一个新的线程对象，使其具有目标作为其运行对象，具有指定的名称作为其名称，并且属于组引用的线程组，并且具有指定的堆栈大小。
线程（线程组，字符串名称）	分配一个新的线程对象。

线程类的方法：

现在让我们来讨论所有的问题方法这一类的内容如下所示：

方法	执行的动作
activeCount（）	返回当前线程的线程组及其子组中活动线程数的估计值
checkAccess（）	确定当前运行的线程是否具有修改此线程的权限
克隆（）	抛出CloneNotSupportedException，因为无法对线程进行有意义的克隆
currentThread（）	返回对当前正在执行的线程对象的引用
转储堆栈（）	将当前线程的堆栈跟踪打印到标准错误流
枚举（线程[]tarray）	将当前线程的线程组及其子组中的每个活动线程复制到指定数组中
getAllStackTraces（）	返回所有活动线程的堆栈跟踪映射
getContextClassLoader（）	返回此线程的上下文类加载器
getDefaultUncaughtExceptionHandler（）	返回因未捕获异常导致线程突然终止时调用的默认处理程序
getId（）	返回此线程的标识符
getName（）	返回此线程的名称
getPriority（）	返回此线程的优先级
getStackTrace（）	返回表示此线程堆栈转储的堆栈跟踪元素数组
getState（）	返回此线程的状态
getThreadGroup（）	返回此线程所属的线程组
getUncaughtExceptionHandler（）	返回由于未捕获的异常导致此线程突然终止时调用的处理程序
holdsLock（对象对象对象）	当且仅当当前线程持有指定对象上的监视器锁时，返回true
中断（）	打断这条线
打断	测试当前线程是否已中断
isAlive（）	测试此线程是否处于活动状态
isDaemon（）	测试此线程是否为守护进程线程
中断	测试此线程是否已中断
加入	等待此线程死亡
加入（长毫秒）	等待此线程死亡的时间最多为毫秒
跑（）	如果这个线程是使用一个单独的Runnable run对象构造的，则调用该Runnable对象的run方法；否则，此方法不执行任何操作并返回
setContextClassLoader（ClassLoader cl）	设置此线程的上下文类加载器
setDaemon（布尔开启）	将此线程标记为守护进程线程或用户线程
setDefaultUncaughtExceptionHandler（Thread.UncaughtExceptionHandler）	设置当线程由于未捕获的异常而突然终止时调用的默认处理程序，并且尚未为该线程定义其他处理程序
集合名（字符串名）	将此线程的名称更改为等于参数名称。
setUncaughtExceptionHandler（Thread.UncaughtExceptionHandler）	设置当该线程由于未捕获的异常而突然终止时调用的处理程序
设置优先级（int newPriority）	更改此线程的优先级
睡眠（长毫秒）	根据系统计时器和调度程序的精度和准确性，使当前执行的线程休眠（暂时停止执行）指定的毫秒数
开始（）	使该线程开始执行；Java虚拟机调用该线程的run方法
toString（）	返回此线程的字符串表示形式，包括线程的名称、优先级和线程组
收益率	向调度程序发出的提示，表明当前线程愿意放弃当前对处理器的使用

还记得有一些 从java类继承的方法。 lang.对象，如下所示：

equals（）方法
finalize（）方法
getClass（）方法
hashCode（）方法
notify（）方法
notifyAll（）方法
toString（）方法
wait（）方法

例子： Java程序演示线程类的用法

JAVA

                           // Java program Demonstrating Methods of Thread class                         
            
                           // Importing package                         
                           package                                        generic;                         
            
                           // Class 1                         
                           // Helper class implementing Runnable interface                         
                           class                                        Helper                                        implements                                        Runnable {                         
            
                                                     //                         
                                                     public                                        void                                        run() {                         
            
                                                     // Try block to check for exceptions                         
                                                     try                                        {                         
            
                                                     // Print statement                         
                                                     System.out.println(                                        "thread2 going to sleep for 5000"                                        );                         
            
                                                     // Making thread sleep for 0.5 seconds                         
                                                     Thread.sleep(                                        5000                                        );                         
            
                                                     }                         
            
                                                     // Catch block to handle exception                         
                                                     catch                                        (InterruptedException e) {                         
            
                                                     // Print statement                         
                                                     System.out.println(                                        "Thread2 interrupted"                                        );                         
                                                     }                         
                                                     }                         
                           }                         
            
                           // Class 2                         
                           // Helper class extensing Runnable interface                         
                           public                                        class                                        Test                                        implements                                        Runnable {                         
            
                                                     // Method 1                         
                                                     // run() method of this class                         
                                                     public                                        void                                        run() {                         
            
                                                     // Thread run() method                         
                                                     }                         
            
                                                     // Method 2                         
                                                     // Main driver method                         
                                                     public                                        static                                        void                                        main(String[] args) {                         
            
                                                     // Making objects of class 1 and 2 in main() method                         
                                                     Test obj =                                        new                                        Test();                         
                                                     Helper obj2 =                                        new                                        Helper();                         
            
                                                     // Creating 2 threads in main() method                         
                                                     Thread thread1 =                                        new                                        Thread(obj);                         
                                                     Thread thread2 =                                        new                                        Thread(obj2);                         
            
                                                     // Moving thread to runnable states                         
                                                     thread1.start();                         
                                                     thread2.start();                         
            
                                                     // Loading thread 1 in class 1                         
                                                     ClassLoader loader = thread1.getContextClassLoader();                         
            
                                                     // Creating 3rd thread in main() method                         
                                                     Thread thread3 =                                        new                                        Thread(                                        new                                        Helper());                         
            
                                                     // Getting number of active threads                         
                                                     System.out.println(Thread.activeCount());                         
                                                     thread1.checkAccess();                         
            
                                                     // Fetching an instance of this thread                         
                                                     Thread t = Thread.currentThread();                         
            
                                                     // Print and display commands                         
                                                     System.out.println(t.getName());                         
            
                                                     System.out.println(                                        "Thread1 name: "                                        + thread1.getName());                         
                                                     System.out.println(                                        "Thread1 ID: "                                        + thread1.getId());                         
            
                                                     // Fetching the priority and state of thread1                         
                                                     System.out.println(                                        "Priority of thread1 = "                                        + thread1.getPriority());                         
            
                                                     // Getting th state of thread 1 using getState() method                         
                                                     // and printing the same                         
                                                     System.out.println(thread1.getState());                         
            
                                                     thread2 =                                        new                                        Thread(obj2);                         
                                                     thread2.start();                         
                                                     thread2.interrupt();                         
                                                     System.out.println(                                        "Is thread2 interrupted? "                                        + thread2.interrupted() );                         
                                                     System.out.println(                                        "Is thread2 alive? "                                        + thread2.isAlive());                         
            
                                                     thread1 =                                        new                                        Thread(obj);                         
                                                     thread1.setDaemon(                                        true                                        );                         
                                                     System.out.println(                                        "Is thread1 a daemon thread? "                                        + thread1.isDaemon());                         
                                                     System.out.println(                                        "Is thread1 interrupted? "                                        + thread1.isInterrupted());                         
            
                                                     // Waiting for thread2 to complete its execution                         
                                                     System.out.println(                                        "thread1 waiting for thread2 to join"                                        );                         
            
                                                     try                                        {                         
                                                     thread2.join();                         
                                                     }                         
            
                                                     catch                                        (InterruptedException e) {                         
            
                                                     // Display the exception along with line number                         
                                                     // using printStackTrace() method                         
                                                     e.printStackTrace();                         
                                                     }                         
            
                                                     // Now setting the name of thread1                         
                                                     thread1.setName(                                        "child thread xyz"                                        );                         
            
                                                     // Print and display command                         
                                                     System.out.println(                                        "New name set for thread 1"                                        + thread1.getName());                         
            
                                                     // Setting the priority of thread1                         
                                                     thread1.setPriority(                                        5                                        );                         
            
                                                     thread2.yield();                         
            
                                                     // Fetching the string representation of thread1                         
                                                     System.out.println(thread1.toString());                         
            
                                                     // Getting list of active thread in current thread's group                         
                                                     Thread[] tarray =                                        new                                        Thread[                                        3                                        ];                         
            
                                                     Thread.enumerate(tarray);                         
            
                                                     // Display commands                         
                                                     System.out.println(                                        "List of active threads:"                                        );                         
                                                     System.out.printf(                                        "["                                        );                         
            
                                                     // Looking out using for each loop                         
                                                     for                                        (Thread thread : tarray) {                         
            
                                                     System.out.println(thread);                         
                                                     }                         
            
                                                     // Display commands                         
                                                     System.out.printf(                                        "]"                                        );                         
            
                                                     System.out.println(Thread.getAllStackTraces());                         
            
                                                     ClassLoader classLoader = thread1.getContextClassLoader();                         
                                                     System.out.println(classLoader.toString());                         
                                                     System.out.println(thread1.getDefaultUncaughtExceptionHandler());                         
            
                                                     thread2.setUncaughtExceptionHandler(thread1.getDefaultUncaughtExceptionHandler());                         
                                                     thread1.setContextClassLoader(thread2.getContextClassLoader());                         
                                                     thread1.setDefaultUncaughtExceptionHandler(thread2.getUncaughtExceptionHandler());                         
            
                                                     thread1 =                                        new                                        Thread(obj);                         
                                                     StackTraceElement[] trace = thread1.getStackTrace();                         
            
                                                     System.out.println(                                        "Printing stack trace elements for thread1:"                                        );                         
            
                                                     for                                        (StackTraceElement e : trace) {                         
                                                     System.out.println(e);                         
                                                     }                         
            
                                                     ThreadGroup grp = thread1.getThreadGroup();                         
                                                     System.out.println(                                        "ThreadGroup to which thread1 belongs "                                        + grp.toString());                         
                                                     System.out.println(thread1.getUncaughtExceptionHandler());                         
                                                     System.out.println(                                        "Does thread1 holds Lock? "                                        + thread1.holdsLock(obj2));                         
            
            
                                                     Thread.dumpStack();                         
            
                                                     }                         
                           }                         

输出：

3mainThread1 name: Thread-0Thread1 ID: 10Priority of thread1 = 5RUNNABLEIs thread2 interrupted? falseIs thread2 alive? trueIs thread1 a daemon thread? trueIs thread1 interrupted? falsethread1 waiting for thread2 to jointhread2 going to sleep for 5000 msthread2 going to sleep for 5000 msThread2 interruptedNew name set for thread 1child thread xyzThread[child thread xyz, 5, main]List of active threads:[Thread[main, 5, main]Thread[Thread-1, 5, main]null]{Thread[Signal Dispatcher, 9, system]=[Ljava.lang.StackTraceElement;@33909752, Thread[Thread-1, 5, main]=[Ljava.lang.StackTraceElement;@55f96302, Thread[main, 5, main]=[Ljava.lang.StackTraceElement;@3d4eac69, Thread[Attach Listener, 5, system]=[Ljava.lang.StackTraceElement;@42a57993, Thread[Finalizer, 8, system]=[Ljava.lang.StackTraceElement;@75b84c92, Thread[Reference Handler, 10, system]=[Ljava.lang.StackTraceElement;@6bc7c054}sun.misc.Launcher$AppClassLoader@73d16e93nullPrinting stack trace elements for thread1:ThreadGroup to which thread1 belongs java.lang.ThreadGroup[name=main, maxpri=10]java.lang.ThreadGroup[name=main, maxpri=10]Does thread1 holds Lock? falsejava.lang.Exception: Stack trace    at java.lang.Thread.dumpStack(Unknown Source)    at generic.Test.main(Test.java:111)

本文由 马扬克·库马尔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java