• Tags
  •         
  • www.breakyizhan.com
  •    

    在程序中线程执行一行。每个程序可以有多个关联的线程。每个线程都有一个优先级,线程调度程序使用该优先级来确定哪个线程必须首先运行。Java提供了一个线程类,它具有各种方法调用,以便管理线程的行为。
    注意:用作线程的每个类都必须实现Runnable接口并覆盖它的run方法。

    Java中的Java.lang.Thread类的构造函数:

    • Thread():分配一个新的Thread对象
    • Thread(Runnable target):分配一个新的Thread对象
    • Thread(Runnable target,String name):分配一个新的Thread对象
    • Thread(String name):分配一个新的Thread对象
    • Thread(ThreadGroup group, Runnable target): 分配新的Thread对象
    • Thread(ThreadGroup group, Runnable target, String name): 分配一个新的Thread对象,使其具有target作为其运行对象,具有指定的名称作为其名称,并且属于group引用的线程组
    • Thread(ThreadGroup group, Runnable target, String name, long stackSize): 分配一个新的Thread对象,使其具有target作为其运行对象,具有指定的名称作为其名称,并且属于group引用的线程组,并且具有指定的堆栈大小
    • Thread(ThreadGroup组,String name):CAllocates一个新的Thread对象

     

    public class Thread
        extends Object
        implements Runnable

    Java中的Java.lang.Thread类的方法:

    1. activeCount():java.lang.Thread.activeCount()返回当前线程的线程组及其子组中活动线程数的估计值句法:
      public static int activeCount()
       返回:
      估计当前活动线程的数量
      线程的线程组和任何其他线程组 
      当前线程的线程组作为祖先
    2. checkAccess():java.lang.Thread.checkAccess()确定当前运行的线程是否有权修改此线程句法:
      public final void checkAccess()
       抛出:
      SecurityException  - 如果不允许当前线程访问。
    3. clone():java.lang.Thread.clone()抛出CloneNotSupportedException,因为无法有意义地克隆线程句法:
      protected Object clone()throws CloneNotSupportedException
       抛出:
      CloneNotSupportedException  - 始终抛出这个异常
      返回: 
      此实例的克隆
    4. currentThread():java.lang.Thread.currentThread()返回对当前正在执行的线程对象的引用句法:
      public static Thread currentThread()
       返回: 
      当前正在执行的线程
    5. dumpStack():java.lang.Thread.dumpStack()将当前线程的堆栈跟踪打印到标准错误流句法:
      public static void dumpStack()
       描述:
      将当前线程的堆栈跟踪打印到标准的错误流。此方法仅用于调试
    6. enumerate(Thread [] tarray):java.lang.Thread.enumerate(Thread [] tarray)将当前线程的线程组及其子组中的每个活动线程复制到指定的数组中句法:
      public static int enumerate(Thread [] tarray)
       参数:
      tarray  - 放置线程列表的数组
      返回:
      放入数组的线程数
      抛出:
      SecurityException  - 如果ThreadGroup.checkAccess()确定当前线程不能 
      访问其线程组
    7. getAllStackTraces():java.lang.Thread.getAllStackTraces()返回所有活动线程的堆栈跟踪映射句法:
      public static Map getAllStackTraces()
       返回:
      从Thread到StackTraceElement数组的映射表示 相应线程的堆栈跟踪
      抛出:
      SecurityException  - 如果存在安全管理器及其checkPermission方法 
      不允许获取线程的堆栈跟踪
    8. getContextClassLoader():java.lang.Thread.getContextClassLoader()返回此Thread的上下文ClassLoader句法:
      public ClassLoader getContextClassLoader()
       返回:
      此Thread的上下文ClassLoader,或null表示系统类加载器 
      (或者,失败,引导类加载器)
      抛出: 
      SecurityException  - 如果当前线程无法获取上下文ClassLoader
    9. getDefaultUncaughtExceptionHandler():java.lang.Thread.getDefaultUncaughtExceptionHandler()返回由于未捕获的异常导致线程突然终止时调用的默认处理程序句法:
      public static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()
       返回: 
      所有线程的默认未捕获异常处理程序
    10. getId():java.lang.Thread.getId()返回此Thread的标识符句法:
      public long getId()
       返回: 
      此线程的ID
    11. getName():java.lang.Thread.getName()返回此线程的名称句法:
      public final String getName()
       返回: 
      此线程的名称
    12. getPriority():java.lang.Thread.getPriority()返回此线程的优先级句法:
      public final int getPriority()
       返回: 
      此线程的优先级
    13. getStackTrace():java.lang.Thread.getStackTrace()返回表示此线程的堆栈转储的堆栈跟踪元素数组句法:
      public StackTraceElement [] getStackTrace()
       返回:
      StackTraceElement数组,每个表示一个堆栈帧
      抛出:
      SecurityException  - 如果存在安全管理器及其 
      checkPermission方法没有 
      允许获取线程的堆栈跟踪
    14. getState():java.lang.Thread.getState()返回此线程的状态句法:
      public Thread.State getState()
       返回: 
      此线程的状态
    15. getThreadGroup():java.lang.Thread.getThreadGroup()返回此线程所属的线程组句法:
      public final ThreadGroup getThreadGroup()
       返回: 
      此线程的线程组
    16. getUncaughtExceptionHandler():java.lang.Thread.getUncaughtExceptionHandler()返回此线程由于未捕获的异常而突然终止时调用的处理程序句法:
      public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
       返回: 
      此线程的未捕获异常处理程序
    17. holdsLock(Object obj):java.lang.Thread.holdsLock(Object obj)当且仅当当前线程持有指定对象上的监视器锁时返回true句法:
      public static boolean holdsLock(Object obj)
       参数:
      obj  - 测试锁所有权的对象
      返回:
      如果当前线程持有监视器锁定,则为true 
      在指定的对象上。
      抛出: 
      NullPointerException  - 如果obj为null
    18. interrupt():java.lang.Thread.interrupt()中断此线程句法:
      public void interrupt() 
       抛出: 
      SecurityException  - 如果当前线程无法修改此线程
    19. interrupted():java.lang.Thread.interrupted()测试当前线程是否已被中断句法:
      public static boolean interrupted()
       返回: 
      如果当前线程已被中断,则返回 true; 否则是假的
    20. isAlive():java.lang.Thread.isAlive()测试此线程是否处于活动状态句法:
      public final boolean isAlive()返回: 
      如果此线程处于
       活动状态,则返回 true; 否则是假的
    21. isDaemon():java.lang.Thread.isDaemon()测试此线程是否为守护程序线程句法:
      public final boolean isDaemon()
       返回: 
      如果此线程是守护程序线程,则返回 true;否则返回 false。否则是假的
    22. isInterrupted():java.lang.Thread.isInterrupted()测试此线程是否已被中断句法:
      public boolean isInterrupted()
       返回: 
      如果此线程已被中断,则返回 true;否则返回 false。否则是假的
    23. join():java.lang.Thread.join()等待此线程死亡句法:
      public final void join()throws InterruptedException
       抛出:
      InterruptedException  - 如果有任何线程中断了 
      当前线程。当前线程的中断状态是
      抛出此异常时清除
    24. join(long millis):java.lang.Thread.join(long millis)此线程最多等待毫秒毫秒句法:
      public final void join(long millis)throws InterruptedException
       参数:
      毫秒 - 等待的时间,以毫秒为单位
      抛出:
      
      IllegalArgumentException  - 如果millis的值为负数
      InterruptedException  - 如果有任何线程中断了当前线程。
      清除当前线程的中断状态 
      何时抛出此异常。
    25. run():java.lang.Thread.run()如果使用单独的Runnable运行对象构造此线程,则调用该Runnable对象的run方法; 否则,此方法不执行任何操作并返回句法:
      public void run()
       描述:
      如果此线程是使用单独的Runnable运行对象构造的,
      然后调用Runnable对象的run方法; 
      否则,此方法不执行任何操作并返回。
      
      Thread的子类应该重写此方法。
    26. yield():java.lang.Thread.yield()向调度程序提示当前线程是否愿意产生当前使用的处理器句法:
      public static void yield()
       描述:
      向调度程序提示当前线程是否愿意 
      产生目前使用的a 
      处理器。调度程序可以忽略此提示
    27. toString():java.lang.Thread.toString()返回此线程的字符串表示形式,包括线程的名称,优先级和线程组句法:
      public String toString()
       返回: 
      此线程的字符串表示形式
    28. start():java.lang.Thread.start()使该线程开始执行; Java虚拟机调用此线程的run方法句法:
      public void start()
       抛出: 
      IllegalThreadStateException  - 如果线程已经启动。
    29. sleep(long millis):java.lang.Thread.sleep(long millis)使当前正在执行的线程休眠(暂时停止执行)指定的毫秒数,具体取决于系统定时器和调度程序的精度和准确性句法:
      public static void sleep(long millis)throws InterruptedException
       参数:
      millis  - 以毫秒为单位的睡眠时间
      抛出:
      IllegalArgumentException  - 如果millis的值为负数
      InterruptedException  - 如果有任何线程中断了 
      当前线程。当前线程的中断状态
      抛出此异常时清除。
    30. setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh):java.lang.Thread.setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)设置当此线程由于未捕获的异常而突然终止时调用的处理程序句法:
      public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
       参数:
      呃 - 用作此线程的未捕获异常处理程序的对象。 
      如果为null,则此线程没有显式处理程序。
      抛出:
      SecurityException  - 如果不允许当前线程
      修改这个帖子。
    31. setPriority(int newPriority):java.lang.Thread.setPriority(int newPriority)更改此线程的优先级句法:
      public final void setPriority(int newPriority)
       参数:
      newPriority  - 将此线程设置为的优先级
      抛出:
      IllegalArgumentException-如果优先级不在范围内 
      MIN_PRIORITY到MAX_PRIORITY
      SecurityException  - 如果当前线程无法修改此线程。
    32. setName(String name):java.lang.Thread.setName(String name)将此线程的名称更改为等于参数名称。句法:
      public final void setName(String name)
       参数:
      name  - 此线程的新名称。
      抛出: 
      SecurityException  - 如果当前线程无法修改此线程。
    33. setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh):java.lang.Thread.setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)设置当线程由于未捕获的异常而突然终止时调用的默认处理程序,并且没有为该线程定义其他处理程序句法:
      public static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
       参数:
      eh - 用作默认未捕获异常处理程序的对象。 
      如果为null则没有 
      默认处理程序
      抛出:
      SecurityException  - 如果存在安全管理器并且 
      它否认RuntimePermission(“setDefaultUncaughtExceptionHandler”)
    34. setDaemon(boolean on):java.lang.Thread.setDaemon(boolean on)将此线程标记为守护程序线程或用户线程句法:
      public final void setDaemon(boolean on)
       参数:
      on  - 如果为true,则将此线程标记为守护程序线程
      抛出:
      IllegalThreadStateException  - 如果此线程处于活动状态
      SecurityException  - 如果checkAccess()确定当前 
      线程无法修改此线程
    35. setContextClassLoader(ClassLoader cl):java.lang.Thread.setContextClassLoader(ClassLoader cl)为此线程设置上下文ClassLoader句法:
      public void setContextClassLoader(ClassLoader cl)
       参数:
      cl  - 此Thread的上下文ClassLoader,或null表示 
      系统类加载器(或者,失败的,引导类加载器)
      抛出:
      SecurityException  - 如果当前线程无法设置 
      context ClassLoader

    Java.lang.Thread类从类java.lang.Object继承的方法

    • equals
    • finalize
    • getClass
    • hashCode
    • notify
    • notifyAll
    • toString
    • wait

    用于演示Java.lang.Thread类类使用的Java程序

    // Java program to demonstrate
    // method calls of Thread class
    package generic;
    class Helper implements Runnable
    {
        public void run()
        {
            try
            {
                System.out.println("thread2 going to sleep for 5000");
                Thread.sleep(5000);
            } catch (InterruptedException e)
            {
                System.out.println("Thread2 interrupted");}
            }
    }
    public class Test implements Runnable
    {
        public void run()
        {
            //thread run() method
        }
        public static void main(String[] args)
        {
            Test obj = new Test();
            Helper obj2 = new Helper();
                 
            Thread thread1 = new Thread(obj);
            Thread thread2 = new Thread(obj2);
             
            // moving thread to runnable states
            thread1.start();
            thread2.start();
                 
            ClassLoader loader = thread1.getContextClassLoader();
            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();
             
            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());
             
            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)
            {
                e.printStackTrace();
            }
                 
            // setting the name of thread1
            thread1.setName("child thread xyz");
            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);
            System.out.println("List of active threads:");
            System.out.printf("[");
            for(Thread thread : tarray)
            {
                System.out.println(thread);
            }
            System.out.printf("]\n");
                 
            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();
                 
        }
    }
    

    输出:

    3
    main
    Thread1 name: Thread-0
    Thread1 ID: 10
    Priority of thread1 = 5
    RUNNABLE
    Is thread2 interrupted? false
    Is thread2 alive? true
    Is thread1 a daemon thread? true
    Is thread1 interrupted? false
    thread1 waiting for thread2 to join
    thread2 going to sleep for 5000 ms
    thread2 going to sleep for 5000 ms
    Thread2 interrupted
    New name set for thread 1child thread xyz
    Thread[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@73d16e93
    null
    Printing 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? false
    java.lang.Exception: Stack trace
    at java.lang.Thread.dumpStack(Unknown Source)
    at generic.Test.main(Test.java:111)
    
     
    转载请保留页面地址:https://www.breakyizhan.com/java/4942.html