currentThread()

currentThread()方法可返回代码段正在被哪个线程调用的信息。
Thread.currentThread().getName();

Example:

class MyThread1 extends Thread {
    MyThread1(){
        System.out.println("执行构造函数"+Thread.currentThread().getName());
    }
    @Override
    public void run() {
        super.run();
        System.out.println("run方法"+Thread.currentThread().getName());
    }
}
public class Run {
    public static void main(String[] args) {
       MyThread1 myThread1= new MyThread1();
       myThread1.start();
       System.out.println("main方法"+Thread.currentThread().getName());
    }
}

Result：

执行构造函数main
main方法main
run方法Thread-0

从运行结果可以看出，MyThread1的构造函数是被main线程调用的，而run()是被名称为Thread-0的线程调用的，run()是自动调用的。

isAlive()

isAlive()判断当前线程是否处于活动状态

Example:

class MyThread1 extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("run="+isAlive());
    }
}
public class Run {
    public static void main(String[] args) {
       MyThread1 myThread1= new MyThread1();
        System.out.println("begin="+myThread1.isAlive());
        myThread1.start();
        try {
            Thread.sleep(1000);
            System.out.println("end="+myThread1.isAlive());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Result：

begin=false
run=true
end=false

end=false，由于Thread.sleep(1000)后，myThread1的run方法以及执行完毕了。所以end=false

sleep()

sleep()方法的作用是在指定的毫秒数内让当前正在执行的线程进行休眠(暂停执行).这个正在执行的线程是指this.currentThread()返回的的线程

Example：

class MyThread1 extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("MyThread1 begin"+System.currentTimeMillis());
        try {
            Thread.sleep(2000);
            System.out.println("MyThread1 end"+System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}
public class Run {
    public static void main(String[] args) {
        MyThread1 myThread1=new MyThread1();
        System.out.println("main begin"+System.currentTimeMillis());
        myThread1.start();
        System.out.println("main end"+System.currentTimeMillis());
    }
}

Result：

main begin1497171784723
main end1497171784723
MyThread1 begin1497171784738
MyThread1 end1497171786739

由于main线程与MyThread1线程是异步执行的，所以首先打印的信息是main begin 和 main end，并且时间是相等的，而MyThread1线程是随后运行的，所以打印MyThread1 begin 和 MyThread1 end ，注意相差2000

getId()

该方法是取得线程的唯一标识

停止线程

停止一个线程意味着在线程处理完任务前停掉正在做的操作。
有3种方式可以终止正在运行的线程

• 使用退出标志,使线程正常退出，也就是run方法完成后退出
• 使用stop(强烈不推荐)，这种暴力停止有可能使一些请理性的工作得不到完成。而且对锁定的对象进行了解锁，导致数据得不到同步的吹，出现数据不一致的问题。
• 使用interrupt方法

interrupt()

调用interrupt()并不会直接停止该线程，只是在当前线程中打了一个停止的标记

Example:

class MyThread1 extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 500000; i++) {
            System.out.println(i);
        }

    }
}
public class Run {
    public static void main(String[] args) {
        MyThread1 myThread1=new MyThread1();
        myThread1.start();
        try {
            Thread.sleep(2000);
            myThread1.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Result：

...
...
499997
499998
499999

从结果可以看到，interrupt()并没有停止该线程。

this.interrupted()和this.isInterrupted()区别

this.interrupted()：测试当前线程是否已经中断,这里当前线程是指运行this.isterrupted()方法的线程,具有将状态标志置清除为false
this.isInterrrupted():测试线程是否已经中断,不清除状态标志

yield()

该方法作用是放弃当前CPU资源，将它让给其他的任务去占用CPU执行时间。但放弃时间不确定。

class MyThread1 extends Thread {
    @Override
    public void run() {
        super.run();
        long beginTime = System.currentTimeMillis();
        for (int i = 0; i < 50000; i++) {
           // Thread.yield();
            i++;
        }
        long endTime = System.currentTimeMillis();
        System.out.println(endTime-beginTime);
    }
}
public class Run {
    public static void main(String[] args) {
        MyThread1 myThread1=new MyThread1();
        myThread1.start();
    }
}

注释掉Thread.yield()，输出1，解开的话11。

线程优先级(setPriority())

设置线程的优先级使用setPriorty()。一共分为1~10这10个等级。
线程优先级特性:

• 继承性:A线程启动B线程，则B线程和A线程优先级是一样的
• 规则性:CPU尽量将执行资源让给优先级较高的线程
• 随机性:优先级较高的线程不一定每一次都先执行完。