3.Thread中的静态方法

1.currentThread()

public class Thread14 extends Thread{
    static {
        System.out.println("静态块的打印：" + Thread.currentThread().getName());
    }
    public Thread14() {
        System.out.println("构造方法的打印： " + Thread.currentThread().getName());
    }
    public void run() {
        System.out.println("run()方法的打印：" + Thread.currentThread().getName());
    }
    
    //test
    public static void main(String[] args) {
        Thread14 thread14 = new Thread14();
        thread14.start();
    }

}

运行结果：

静态块的打印：main
构造方法的打印： main
run()方法的打印：Thread-0

这个例子说明了，线程的构造方法、静态块是被main线程调用的，而线程类的run()方法才是应用线程自己调用的。

public class Thread15 extends Thread{

    public Thread15() {
        System.out.println("thread15 ---->begin");
        System.out.println("Thread.currentThread().getName()----->" + Thread.currentThread().getName());
        System.out.println("this.getName()----->" + this.getName());
        System.out.println("thread15---->end");
    }
    
    public void run() {
        System.out.println("run------->begin");
        System.out.println("Thread.currentThread.getName()---->" + Thread.currentThread().getName());
        System.out.println("this.getName()------>" + this.getName());
        System.out.println("run------>end");
    }
    public static void main(String[] args) {
        Thread15 thread15 = new Thread15();
        thread15.start();
    }
}

运行结果：

thread15 ---->begin
Thread.currentThread().getName()----->main
this.getName()----->Thread-0
thread15---->end
run------->begin
Thread.currentThread.getName()---->Thread-0
this.getName()------>Thread-0
run------>end

当在执行Thread15 thread15 = new Thread15()的时候，this.getName也就是当前线程却是Thread-0.

 

2.sleep(long millions)

该方法的作用是在指定的时间内让当前正在执行的线程Thread.currentThread()暂停执行，也就是休眠。值得注意的一点是，该方法并不让出cpu资源，换句话说，也就是CPU依然在执行run（）中的内容，无非这个内容是休眠而已。

public class Thread16 extends Thread{
    public void run() {
        try{
        System.out.println("run threadName= " + this.getName() + " begin");
        Thread.sleep(20000);
        System.out.println("run threadName= " + this.getName() + " end");
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Thread16 thread16 = new Thread16();
        System.out.println("begin= " + System.currentTimeMillis());
        thread16.start();
        System.out.println("end= " + System.currentTimeMillis());
    }

}

执行结果：

begin= 1447813479735
end= 1447813479736
run threadName= Thread-0 begin
run threadName= Thread-0 end

System.out.print是静态方法，因此输出的内容很快就会完成。启动的线程中有个休眠过程，thread-0 begin 和 thread-0 end 中间就会有等待。

3.yield()

public class Thread17 extends Thread{
    public void run() {
        long beginTime = System.currentTimeMillis();
        int count = 0;
        for(int i = 0; i < 50000000; i++) {
            Thread.yield();//去掉之后明显整个程序运行时间剪短
            count = count + i + 1;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("用时：" + (endTime - beginTime) + "毫秒" + count);
    }
    
    public static void main(String[] args) {
        Thread17 thread17 = new Thread17();
        thread17.start();
//        Thread.currentThread().interrupt();
//        System.out.println("1---" + Thread.interrupted());
//        System.out.println("2---" + Thread.interrupted());
    }

}

yield()就是暂停当前执行的线程，并执行其他线程。这个暂停会是放弃cpu资源的，并且放弃cpu时间不确定，有可能刚放弃就又获得了。因此这里因为yield（）方法中间消耗的时间也是不确定的。

4.interrupted()

public static void main(String[] args) {
//        Thread17 thread17 = new Thread17();
//        thread17.start();
        Thread.currentThread().interrupt();
        System.out.println("1---" + Thread.interrupted());
        System.out.println("2---" + Thread.interrupted());
    }

测试当前线程是否已经中断，执行后就将状态标示改为false。因此，两次调用后返回必然为false

执行结果：

1---true
2---false