精华内容
下载资源
问答
  • java中Thread类方法介绍

    千次阅读 2016-11-29 17:13:05
    方法摘要  static int activeCount()   返回当前线程的线程组活动线程的数目。   void checkAccess()   判定当前运行的线程是否有权修改该线程。   int countStackFrames()   已过时。 该调用的...
    方法摘要 
    static int activeCount() 
              返回当前线程的线程组中活动线程的数目。 
     void checkAccess() 
              判定当前运行的线程是否有权修改该线程。 
     int countStackFrames() 
              已过时。 该调用的定义依赖于 suspend(),但它遭到了反对。此外,该调用的结果从来都不是意义明确的。 
    static Thread currentThread() 
              返回对当前正在执行的线程对象的引用。 
     void destroy() 
              已过时。 该方法最初用于破坏该线程,但不作任何清除。它所保持的任何监视器都会保持锁定状态。不过,该方法决不会被实现。即使要实现,它也极有可能以 suspend() 方式被死锁。如果目标线程被破坏时保持一个保护关键系统资源的锁,则任何线程在任何时候都无法再次访问该资源。如果另一个线程曾试图锁定该资源,则会出现死锁。这类死锁通常会证明它们自己是“冻结”的进程。有关更多信息,请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume?。 
    static void dumpStack() 
              将当前线程的堆栈跟踪打印至标准错误流。 
    static int enumerate(Thread[] tarray) 
              将当前线程的线程组及其子组中的每一个活动线程复制到指定的数组中。 
    static Map<Thread,StackTraceElement[]> getAllStackTraces() 
              返回所有活动线程的堆栈跟踪的一个映射。 
     ClassLoader getContextClassLoader() 
              返回该线程的上下文 ClassLoader。 
    static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() 
              返回线程由于未捕获到异常而突然终止时调用的默认处理程序。 
     long getId() 
              返回该线程的标识符。 
     String getName() 
              返回该线程的名称。 
     int getPriority() 
              返回线程的优先级。
     
     StackTraceElement[] getStackTrace() 
              返回一个表示该线程堆栈转储的堆栈跟踪元素数组。 
     Thread.State getState() 
              返回该线程的状态。 
     ThreadGroup getThreadGroup() 
              返回该线程所属的线程组。 
     Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() 
              返回该线程由于未捕获到异常而突然终止时调用的处理程序。 
    static boolean holdsLock(Object obj) 
              当且仅当当前线程在指定的对象上保持监视器锁时,才返回 true。 
     void interrupt() 
              中断线程。 
    static boolean interrupted() 
              测试当前线程是否已经中断。 
     boolean isAlive() 
              测试线程是否处于活动状态。 
     boolean isDaemon() 
              测试该线程是否为守护线程。 
     boolean isInterrupted() 
              测试线程是否已经中断。 
     void join() 
              等待该线程终止。 
     void join(long millis) 
              等待该线程终止的时间最长为 millis 毫秒。 
     void join(long millis, int nanos) 

              等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。 
     void resume() 
              已过时。 该方法只与 suspend() 一起使用,但 suspend() 已经遭到反对,因为它具有死锁倾向。有关更多信息,请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume?。 
     void run() 
              如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。 
     void setContextClassLoader(ClassLoader cl) 
              设置该线程的上下文 ClassLoader。 
     void setDaemon(boolean on) 
              将该线程标记为守护线程或用户线程。 
    static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) 
              设置当线程由于未捕获到异常而突然终止,并且没有为该线程定义其他处理程序时所调用的默认处理程序。 
     void setName(String name) 
              改变线程名称,使之与参数 name 相同。 
     void setPriority(int newPriority) 
              更改线程的优先级。 
     void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) 
              设置该线程由于未捕获到异常而突然终止时调用的处理程序。 
    static void sleep(long millis) 
              在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。 
    static void sleep(long millis, int nanos) 
              在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。 
     void start() 

              使该线程开始执行;Java 虚拟机调用该线程的 run 方法。 
     void stop() 
              已过时。 该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器(作为沿堆栈向上传播的未检查 ThreadDeath 异常的一个自然后果)。如果以前受这些监视器保护的任何对象都处于一种不一致的状态,则损坏的对象将对其他线程可见,这有可能导致任意的行为。stop 的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量,并且如果该变量指示它要停止运行,则从其运行方法依次返回。如果目标线程等待很长时间(例如基于一个条件变量),则应使用 interrupt 方法来中断该等待。有关更多信息,请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume?。 
     void stop(Throwable obj) 
              已过时。 该方法具有固有的不安全性。有关详细信息,请参阅 stop()。该方法的附加危险是它可用于生成目标线程未准备处理的异常(包括若没有该方法该线程不太可能抛出的已检查的异常)。有关更多信息,请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume?。 
     void suspend() 
              已过时。 该方法已经遭到反对,因为它具有固有的死锁倾向。如果目标线程挂起时在保护关键系统资源的监视器上保持有锁,则在目标线程重新开始以前任何线程都不能访问该资源。如果重新开始目标线程的线程想在调用 resume 之前锁定该监视器,则会发生死锁。这类死锁通常会证明自己是“冻结”的进程。有关更多信息,请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume?。 
     String toString() 
              返回该线程的字符串表示形式,包括线程名称、优先级和线程组。 
    static void yield() 
              暂停当前正在执行的线程对象,并执行其他线程。
     
    展开全文
  • java中Thread类的join方法

    千次阅读 2017-11-13 13:21:03
    那么我们如何实现让线程T1,T2,T3,在T1执行完成后才执行T2,T2执行完成后才执行T3,也就是线程的串行化,通过Thread类的join方法就可以实现。 join方法:将该线程加入当前线程,当前线程等待加入线程执行完成...
    单核cpu运行多线程时底层实现原理是多个线程间切换,由于cpu的处理速度很快,看上去像多个线程同时运行。那么我们如何实现让线程T1,T2,T3,在T1执行完成后才执行T2,T2执行完成后才执行T3,也就是线程的串行化,通过Thread类的join方法就可以实现。

    join方法:将该线程加入当前线程,当前线程等待加入线程执行完成才继续执行。
    例子:
    public class ThreadJoinTest implements Runnable {
    public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new ThreadJoinTest());
    thread.start();
    thread.join();
    System.out.println("主线程结束");
    }

    @Override
    public void run() {
    System.out.println("子线程开始");
    for(int i = 0; i < 5; i++) {
    try {
    Thread.sleep(1000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(i);
    }
    System.out.println("子线程结束");
    }
    }
    执行结果:
    join(long  millis)方法:将该线程加班当前线程,当前线程等待加入线程millis时间,当达到millis时间后不管加入线程是否完成,当前线程都继续执行,若加入线程在小于millis时间执行完成,则当前线程等待时间等于加入线程的执行时间。
    例子:
    public class ThreadJoinTest implements Runnable {
    public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new ThreadJoinTest());
    thread.start();
    thread.join(2000);
    System.out.println("主线程结束");
    }

    @Override
    public void run() {
    System.out.println("子线程开始");
    for(int i = 0; i < 5; i++) {
    try {
    Thread.sleep(1000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(i);
    }
    System.out.println("子线程结束");
    }
    }
    执行结果:

    展开全文
  • Java中Thread类方法简介

    万次阅读 2018-06-05 17:37:48
    如果直接调用run()方法,该方法也会执行,但会被当做一个普通的方法,在当前线程顺序执行;而如果使用start()方法,则会创建一个新的线程执行run()方法。 2.线程中断 public void interrupt(); public boole.....

    1.新建线程

    Thread t1 = new Thread();
    t1.start();

    新建线程,应该调用start()方法启动线程;如果直接调用run()方法,该方法也会执行,但会被当做一个普通的方法,在当前线程中顺序执行;而如果使用start()方法,则会创建一个新的线程执行run()方法。

    2.线程中断

    public void interrupt();
    public boolean isInterrupted();
    public static boolean interrupted();

    三个方法很相似,线程中断只是通知目标线程有人希望你退出,而并不是使目标线程退出。
    第一个方法是通知目标线程中断,即设置目标线称的中断标志位;
    第二个方法判断当前线程是否被中断,如果被中断(即中断标志位被设置),则返回true,否则返回false;
    第三个方法判断当前线程的中断状态,并清除该线程的中断标志位(也就意味着,如果连续调用两次该方法,并且中间没有再次设置中断标志位,第二次会返回false,因为中断标志位已经被清除)。

    public static native void sleep(long millis) throws InterruptedException;

    sleep()方法会将当前线程休眠若干ms,如果在休眠期间被调用interrupt()方法,则会抛出InterruptedException异常。如下:

    public class TestThread implements Runnable{
        @Override
        public void run() {
            while(true) {
                if(Thread.currentThread().isInterrupted()){ //如果当前线程已经被设置了中断标志位,则返回true
                    System.out.println("Interrupted");
                    break;
                }
    
                try {
                    Thread.currentThread().sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Interruted when sleep!");
                    Thread.currentThread().interrupt(); //Thread.sleep()方法由于中断而抛出异常,此时,它会清除中断标记;
                }
    
                Thread.yield();
            }
        }
    
        public static void main(String[] args){
            Thread t1 = new Thread(new TestThread());
            t1.start();
    
            t1.interrupt(); //设置目标线程的中断标志位,中断标志位表示当前线程已经被中断了
        }
    }

    3.等待(wait)和通知(notify)

    public final void wait() throws InterruptedException;
    public final native void notify();
    public final native void notifyAll();

    obj.wait()是设置当前线程在该对象上等待,直到有线程调用obj.notify()方法(或notifyAll()方法)。当调用wait()方法后,该线程会进入一个等待队列,等待队列中可能有多个线程,notify()会随机唤醒其中一个线程,而notifyAll()会唤醒所有线程。
    wait()和notify()方法必须在sychronized代码块中,调用这些方法时都需要先获得目标对象的一个监视器,然后调用这些方法时会释放监视器
    与sleep不同的是,sleep()会一直占有所持有的锁,而wait()会释放锁。

    4.等待线程(join)和谦让(yield)

    public final void join() throws InterruptedException;
    public static native void yield();

    如果一个线程的执行需要另一个线程的参与(比如当前线程执行需要另一个线程执行完毕才能继续执行),这时候可以调用join()方法。t1.join()方法表示等待线程t1执行完毕之后,当前线程再继续执行。当然也可以给join()设置时间参数。
    注:join()的本质是让调用线程wait()在当前线程对象实例上,其部分源码如下:

    while (isAlive()) {
       wait(0);
    }

    当线程执行完毕后,它会让被等待的线程在退出前调用notifyAll()通知所有等待的线程继续执行。因此不要在Thread对象实例上使用类似wait()或者notify()等方法。
    yield()方法是使当前线程让出CPU,但该线程会再次抢夺CPU。

    展开全文
  • java中Thread类的join()方法

    万次阅读 2012-03-10 11:45:47
    Thread类中有一个join()方法,在一个线程启动另外一个线程的join方法,当前线程将会挂起,而执行被启动的线程,知道被启动的线程执行完毕后,当前线程才开始执行。 下面我们新建两个继承Thread,让其中一个...

    Thread类中有一个join()方法,在一个线程中启动另外一个线程的join方法,当前线程将会挂起,而执行被启动的线程,知道被启动的线程执行完毕后,当前线程才开始执行。

    下面我们新建两个继承Thread的类,让其中一个线程在另外一个线程中调用join方法

    class Thread1 extends Thread
    {
    	public Thread1(String threadName)
    	{	
    		super(threadName);
    	}
    	
    	public void run()
    	{
    		System.out.println(getName() + "is running");
    		try
    		{
    			sleep(2000);
    		} 
    		catch (InterruptedException e)
    		{
    			e.printStackTrace();
    		}
    	}
    }

    class Thread2 extends Thread
    {
    	private Thread1 thread1;
    	
    	public Thread2(String threadName, Thread1 thread1)
    	{
    		super(threadName);
    		this.thread1 = thread1;		
    	}
    	
    	public void run()
    	{
    		System.out.println(getName() +  "is running");
    		try
    		{
    			thread1.start();
    			thread1.join();
    		} 
    		catch (InterruptedException e)
    		{
    			e.printStackTrace();
    		}
    		System.out.println("thread2 is over");	
    	}
    }
    
    package com.thread;
    
    public class JoinTest
    {
    	public static void main(String[] args)
    	{
    		Thread1 thread1 = new Thread1("Thread1");
    		Thread2 thread2 = new Thread2("Thread2", thread1);
    		thread2.start();
    	}
    }


    
    我们在thead2中调用thread1的join()方法,让thread1中断thread2自身的运行,运行程序首先输出thread2 is running,然后输出thread1 is running, 过了两秒钟之后,才输出thread2 is over,这就说明在thread2中调用thread1的join()方法,thread2自身被中断了,转而执行thread1,等待thread1执行完毕之后,再转过来执行thread2

    展开全文
  • Java中Thread类的start()方法和run()方法

    千次阅读 2017-07-05 18:29:17
    我们知道在Java中可以通过继承一个Thread类来实现一个线程,继承以后,需要重载run()方法,但是在启动线程的时候则又是用start()方法,这个是几个意思,启动直接用run()不行么,我们试一下。首先还是用start()方法...
  • JavaThread类中的join()方法原理

    万次阅读 多人点赞 2018-05-09 18:34:09
    join()是Thread类的一个方法。根据jdk文档的定义: public final void join()throws InterruptedException: Waits for this thread to die. join()方法的作用,是等待这个线程结束;但显然,这样的定义并不清晰...
  • 1. 前言线程与进程的理解详见:https://blog.csdn.net/qq_38969070/article/details/80424079多线程处理...(2) 从程序员的角度来看,你在应用开始时,应该只有一个线程, 称之为主线程(main t...
  • Java Thread类主要方法详解

    万次阅读 2018-09-13 00:48:41
    java中,谈到线程,必然少不了Thread类。线程是比进程更轻量级的调度执行单位。为什么用线程?通过使用线程,可以把操作系统进程的资源分配和执行调度分开,各个线程既可以共享进程资源(内存地址、文件I/O等),...
  • java提供了两种线程方式,一种是继承java.lang包下的Thread类,覆写Thread类的run()方法,在run()方法中实现运行在线程上的代码!第二种是实现Runnable接口创建多线程。下面就跟大家具体的介绍一下这两种方式! 在...
  • Java中使用Thread类

    千次阅读 2018-07-17 15:12:45
    那么JVM就要在主线程和其他线程之间轮流切换,保证每个线程都有机会使用CPU资源,main方法即使执行完最后的语句(主线程结束),JVM也不会结束Java应用程序,JVM一直要等到Java应用程序的所有线程都结束之后,才会...
  • JAVA中 Thread Dump 的方法

    千次阅读 2011-11-29 12:00:41
    Thread Dump用来诊断Java应用的问题,可以用来查找内存泄露,发现死锁线程等等。通过它可以得到线程,线程运行状态、标识、调用的堆栈,堆栈包含完整的类名,所执行的方法,以及源代码所在的行数等等信息 使用方法...
  • JAVA线程-Thread类方法

    万次阅读 2016-05-17 15:50:15
    static Thread currentThread() 返回对当前正在执行的线程对象的引用。 long getId()返回该线程的标识符。 String getName()返回该线程的名称。 int getPriority() 返回线程的优先级。 void interrupt() 中断...
  • Java Thread类源码详解

    千次阅读 2018-08-23 14:51:18
    Java所有多线程的实现,均通过封装Thread类实现,所以深入Thread类,对深入理解java多线程很有必要 构造函数: Thread的构造函数,采用缺省的方式实现: //传入Runnable接口实现 Thread...
  • 当一个方法后面声明可能会抛出InterruptedException异常时,说明该方法是可能会花一点时间,但是可以取消的方法...2.Java.lang.Thread类的sleep方法。 3.Java.lang.Thread类的join方法。 这里我们只看sleep方法
  • sleep()方法(休眠)是线程Thread)的静态方法,调用此方法会让当前线程暂停执行指定的时间,将执行机会(CPU)让给其他线程,但是对象的锁依然保持,因此休眠时间结束后会自动恢复(线程会回到就绪状态)。...
  • java中Thread用法

    万次阅读 2015-05-13 10:02:11
    上下文切换三.Thread类中方法线程的状态 在正式学习Thread类中的具体方法之前,我们先来了解一下线程有哪些状态,这个将会有助于后面对Thread类中方法的理解。 线程从创建到最终的消亡,要经历若干个状态。...
  • Java直接调用Thread类中的run()方法

    千次阅读 2016-09-18 11:29:00
    //线程直接调用run()和调用start()后再调用run()的不同 public class Test05 { ... Thread t=new Thread(){ public void run(){ pong(); } }; //t.start();//开启一个新线程,会调用该线程

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,072,861
精华内容 429,144
关键字:

java中thread类的方法

java 订阅