currentThread方法
返回当前正在执行的线程对象；
package venus;
public class Test {
public static void main(String[] args) {
Thread thread = Thread.currentThread();
System.out.println("1-->"+thread);
new TimeThread().start();
}
}
class TimeThread extends Thread{
@Override
public void run() {
Thread thread = Thread.currentThread();
System.out.println("2-->"+thread);
}
}
输出结果
1-->Thread[main,5,main]
2-->Thread[Thread-0,5,main]该方法可以输出线程的信息，三个参数分别为：属于的线程、线程的优先级（0·10，默认为5）、该线程属于的线程组；
join方法
执行该方法的线程进入阻塞状态，直到调用该方法的线程结束之后再由阻塞状态转为执行状态；
package venus;
import java.util.Date;
public class Test {
public static void main(String[] args) {
TimeThread timeThread = new TimeThread();
timeThread.start();
CountThread countThread = new CountThread(timeThread);
countThread.start();
}
}
class CountThread extends Thread{
private TimeThread timeThread;
CountThread(TimeThread timeThread){
this.timeThread = timeThread;
}
@Override
public void run() {
for(int i=0;i<5;i++) {
System.out.println("---->"+i);
if(i==2) {
try {
//执行join方法的现成的阻塞，直到调用join的方法的线程执行完毕
timeThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class TimeThread extends Thread{
@Override
public void run() {
for(int i=0;i<5;i++) {
System.out.println("++++>"+new Date());
}
}
}执行结果如下：
注意：线程对象在调用join方法前必须先调用start方法，否则该线程永远不会进入执行状态。（即上述方法将第9行的代码 countThread.start(); 注销掉，则join方法不会再执行了）
interrupt方法
结束线程在调用Object类的wait方法或该类的join方法、sleep方法过程中的阻塞状态，并在调用wait、join和sleep方法处产生InterruptedException异常；可以这么说 ，该方法可以提前结束调用该方法的线程的阻塞；
package venus;
import java.util.Date;
public class Test {
public static void main(String[] args) {
CountThread countThread = new CountThread();
countThread.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("3秒已过！");
countThread.interrupt(); //提前结束调用该方法的线程的阻塞
}
}
class CountThread extends Thread{
@Override
public void run() {
System.out.println("++++>"+1);
try {
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("++++>"+2);
}
}代码 Thread.sleep(参数); 的作用是：使当前线程堵塞，单位是毫秒；上面代码分别堵塞3秒和10000秒；如果没有 countThread.interrupt() 代码，则 1 和 2 的输出要隔10000秒，现在提前结束了堵塞，则直接输出了，执行结果如下：
isAlive方法
package venus;
public class Test {
public static void main(String[] args) {
Thread thread = Thread.currentThread();
CountThread countThread = new CountThread(thread);
countThread.start();
System.out.println("1-->"+thread.isAlive());
}
}
class CountThread extends Thread{
Thread thread;
CountThread(Thread thread){
this.thread=thread;
}
@Override
public void run() {
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("2-->"+thread.isAlive());
}
}
执行结果如下：
1-->true
2-->false
这里我们可以看到：输出 1 时主线程还没有结束（如果主线程结束了就不会执行输出语句了）；因为子线程阻塞了，所以主线程先执行完毕结束了，因此，子线程阻塞结束之后输出主线程的状态时，是 false；
注意：线程A执行“已死”线程B所调用的jion方法，则线程A不会阻塞。
注意：程序结束时会结束所有的线程，但是主线程结束一般并不会影响子线程的执行；
setDaemon方法
用于将一个尚未调用线程start方法的线程设置为守护线程，守护线程主要用于为其他线程的运行提供服务（Java中的垃圾回收机制就是守护线程），这种线程输入创建它的线程；
注意：守护线程随着最后一个非守护线程的终止而终止；线程对象调用start之前调用setDaemon方法并将其值设置为true，则该线程为守护线程，随着进程中最后一个非守护线程的结束而结束；
package venus;
public class Test {
public static void main(String[] args) {
CountThread countThread = new CountThread();
countThread.setDaemon(true);
countThread.start();
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class CountThread extends Thread{
@Override
public void run() {
while(true) {
System.out.println(111);
}
}
}上例中，子线程本来是一个死循环输出的线程，现在使其成为守护线程，而主线程在在阻塞1毫秒之后结束，则该守护线程则会随着主线程的结束而结束；
执行结果如下：
其他方法
- void start()：使该线程开始启动，Java 虚拟机负责调用该线程的 run() 方法。多次启动一个线程是非法的。
- void sleep(long millis)：Thread类静态方法，线程进入阻塞状态，在指定时间（单位为毫秒）到达之后进入就绪状态（Runnable），而非立即进入执行状态。
- void yield()：静态方法，当前线程放弃占用CPU资源，回到就绪状态，使其他优先级不低于此线程的线程有机会被执行。
- void setPriority(int newPriority)：设置当前线程的优先级，线程优先级越高，线程获得执行的次数越多，Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：
- static int MAX_PRIORITY 最高优先级值为10；
- static int NORM_PRIORITY 默认优先级值为5；
- static int MIN_PRIORITY 最低优先级值为1；
- 注意：同一个线程类创建的多个线程，线程优先级越高的线程获得的执行次数极有可能越多；但是不同线程类创建的线程，线程优先级越高，执行次数不一定越多，这个run方法的代码复杂度有关。
- int getPriority()：获得当前线程的优先级。
