Java多线程4:Thread中的静态方法
一、Thread类中的静态方法
Thread类中的静态方法是通过Thread.方法名来调用的,那么问题来了,这个Thread指的是哪个Thread,是所在位置对应的那个Thread嘛?通过下面的例子可以知道,Thread类中的静态方法所操作的线程是“正在执行该静态方法的线程”,不一定是其所在位置的线程。为什么Thread类中要有静态方法,这样就能对CPU当前正在运行的线程进行操作。下面来看一下Thread类中的静态方法:
1、currentThread()
/** * Returns a reference to the currently executing thread object. * * @return the currently executing thread. */ public static native Thread currentThread();
currentThread()方法返回的是对当前正在执行的线程对象的引用。
举例:
public class Thread01 extends Thread{ static{ System.out.println("静态代码块的打印:" + Thread.currentThread().getName()); } public Thread01(){ System.out.println("构造函数的打印:" +Thread.currentThread().getName()); } @Override public void run() { System.out.println("run方法的打印:" + Thread.currentThread().getName()); } }
public class Test { public static void main(String[] args){ Thread01 thread01 = new Thread01(); thread01.start(); } }
结果:
静态代码块的打印:main
构造函数的打印:main
run方法的打印:Thread-0
可以看到,Thread01类中的三个相同的静态方法Thread.currentThread()所操作的不是同一个线程,虽然写在了Thread01内,但是静态代码块和构造函数中的静态方法是随着main线程而被调用的,run方法中的静态方法则是thread01线程调用的。把thread01.start()注释掉
public class Test { public static void main(String[] args){ Thread01 thread01 = new Thread01(); // thread01.start(); } }
结果:
静态代码块的打印:main
构造函数的打印:main
因为Thread01中的静态代码块和构造方法都是在main线程中被调用的,而run方法是thread01这个线程调用的,所以不一样。
举例说明上篇说的"this.XXX()"和"Thread.currentThread().XXX()"的区别,this表示的线程是线程实例本身,后一种表示的线程是正在执行"Thread.currentThread.XXX()这块代码的线程"
public class Thread01 extends Thread{ public Thread01(){ System.out.println("构造函数中通过this调用:" + this.getName()); System.out.println("构造函数中通过静态方法调用:" + Thread.currentThread().getName()); } @Override public void run() { System.out.println("run方法中通过this调用:" + this.getName()); System.out.println("run方法中通过静态方法调用:" + Thread.currentThread().getName()); } }
public class Test { public static void main(String[] args){ Thread01 thread01 = new Thread01(); thread01.start(); } }
结果:
构造函数中通过this调用:Thread-0 构造函数中通过静态方法调用:main run方法中通过this调用:Thread-0 run方法中通过静态方法调用:Thread-0
同样的,把thread01.start()这一行注释掉以后
public class Test { public static void main(String[] args){ Thread01 thread01 = new Thread01(); // thread01.start(); } }
结果:
构造函数中通过this调用:Thread-0
构造函数中通过静态方法调用:main
所以,在Thread01里面通过Thread.currentThread得到的线程对象的引用不一定就是Thread01,要看该方法所在的代码会被哪个线程调用。
2、sleep(long millis)
/** * Causes the currently executing thread to sleep (temporarily cease * execution) for the specified number of milliseconds, subject to * the precision and accuracy of system timers and schedulers. The thread * does not lose ownership of any monitors. * * @param millis * the length of time to sleep in milliseconds * * @throws IllegalArgumentException * if the value of {@code millis} is negative * * @throws InterruptedException * if any thread has interrupted the current thread. The * <i>interrupted status</i> of the current thread is * cleared when this exception is thrown. */ public static native void sleep(long millis) throws InterruptedException;
sleep(long millis)方法的作用是在指定的毫秒内让当前"正在执行的线程"休眠(暂停执行)。这个"正在执行的线程"是关键,指的是Thread.currentThread()返回的线程。根据JDK API的说法,"该线程不丢失任何监视器的所属权",简单说就是sleep代码上下文如果被加锁了,锁依然在,但是CPU资源会让出给其他线程。
举例:
public class Thread01 extends Thread{ @Override public void run() { try { System.out.println("run threadName:" + this.getName()); System.out.println("调用Thread.sleep方法休眠3秒"); Thread.sleep(3000); System.out.println("run threadName:" + Thread.currentThread().getName()); } catch (InterruptedException e) { e.printStackTrace(); } } }
public class Test { public static void main(String[] args){ System.out.println("main 开始===" + System.currentTimeMillis()); Thread01 thread01 = new Thread01(); thread01.start(); System.out.println("main 结束=====" + System.currentTimeMillis()); } }
结果:
main 开始===1552401515206 main 结束=====1552401515208 run threadName:Thread-0 调用Thread.sleep方法休眠3秒 run threadName:Thread-0
3、yield()
/** * A hint to the scheduler that the current thread is willing to yield * its current use of a processor. The scheduler is free to ignore this * hint. * * <p> Yield is a heuristic attempt to improve relative progression * between threads that would otherwise over-utilise a CPU. Its use * should be combined with detailed profiling and benchmarking to * ensure that it actually has the desired effect. * * <p> It is rarely appropriate to use this method. It may be useful * for debugging or testing purposes, where it may help to reproduce * bugs due to race conditions. It may also be useful when designing * concurrency control constructs such as the ones in the * {@link java.util.concurrent.locks} package. */ public static native void yield();
暂停当前执行的线程,并执行其他的线程。这个暂停是会放弃CPU资源的,并且放弃CPU的时间不确定,有可能刚放弃,就获得CPU资源了,也有可能放弃好一会儿,才会被CPU执行。
举例说明yield()放弃CPU的时间是不一定的,用户无法指定
public class Thread01 extends Thread{ @Override public void run() { for(int i = 1; i <= 500; i++) { long beginTime = System.currentTimeMillis(); Thread.yield(); long endTime = System.currentTimeMillis(); System.out.println(" 第" + i + "次yield 的时长为:" + (endTime - beginTime) + "ms"); System.out.println("i = " + i); } } }
public class Thread02 extends Thread{ @Override public void run() { for(int i = 0; i < 500000; i++) { List<Integer> list = new ArrayList<>(); list.add(i); } } }
public class Test { public static void main(String[] args) { Thread01 thread01 = new Thread01(); thread01.start(); //根据Thread02多开几个线程 Thread02 thread02 = new Thread02(); thread02.start(); Thread02 thread021 = new Thread02(); thread021.start(); Thread02 thread022 = new Thread02(); thread022.start(); Thread02 thread023 = new Thread02(); thread023.start(); Thread02 thread024 = new Thread02(); thread024.start(); } }
结果:
....................................... ....................................... i = 48 第48次yield 的时长为:0ms i = 49 第49次yield 的时长为:0ms i = 50 第50次yield 的时长为:1ms i = 51 第51次yield 的时长为:0ms i = 52 第52次yield 的时长为:4ms i = 53 第53次yield 的时长为:0ms i = 54 第54次yield 的时长为:0ms ....................................... ....................................... i = 442 第442次yield 的时长为:0ms i = 443 第443次yield 的时长为:0ms i = 444 第444次yield 的时长为:1ms i = 445 第445次yield 的时长为:0ms i = 446 第446次yield 的时长为:0ms ....................................... .......................................
可以看到,yield()方法放弃CPU的时间是不确定的,可能立马就被CPU执行,也可能要等待一会再被CPU执行。
4、interrupted()
/** * Tests whether the current thread has been interrupted. The * <i>interrupted status</i> of the thread is cleared by this method. In * other words, if this method were to be called twice in succession, the * second call would return false (unless the current thread were * interrupted again, after the first call had cleared its interrupted * status and before the second call had examined it). * * <p>A thread interruption ignored because a thread was not alive * at the time of the interrupt will be reflected by this method * returning false. * * @return <code>true</code> if the current thread has been interrupted; * <code>false</code> otherwise. * @see #isInterrupted() * @revised 6.0 */ public static boolean interrupted() { return currentThread().isInterrupted(true); }
测试当前线程是否处于中断状态,调用该方法,线程中断状态的标识被清除(置为false),也就是说,如果这个方法被连续调用两次,第二次一定会返回false
public class Test { public static void main(String[] args) { Thread.currentThread().interrupt(); System.out.println(Thread.currentThread().getName() + "线程是否被中断?" + Thread.interrupted()); System.out.println(Thread.currentThread().getName() + "线程是否被中断?" + Thread.interrupted()); } }
结果:
main线程是否被中断?true main线程是否被中断?false
当然,这也涉及Java的中断机制,留在后面的一篇文章专门讲解。
参考资料: