线程中常用的方法

①interrupt方法：
作用结束线程在调用Object类的wait方法或该类的join方法、sleep方法过程中的阻塞状态，并在调用wait、join和sleep方法处产生InterruptedException异常。

//thread.interrupt();方法被注释掉时
public class InterRupt {
	
	public static void main(String[] args) {
		Thread thread=new Thread(new TTime());
		thread.start();		
		try {
			Thread.sleep(5000);			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("1"+new java.util.Date());
		//thread.interrupt();
	}
}
class TTime implements Runnable{
	
	@Override
	public void run() {
			try {
				Thread.sleep(30000);
			} catch (InterruptedException e) {				
				e.printStackTrace();
			}	
		System.err.println("XXXXXXXXXXXXXXXXXXXXXX"+new java.util.Date());
	}	
}

控制台输出如下

取消注释，结束阻塞以后，控制台输出如下

②currentThread方法
作用返回当前正在执行的线程对象。

public class Cuur {
	public static void main(String[] args) {
		Thread thread=new Thread(new TSime());
		thread.start();		
		System.out.println(thread);
	}
}
class TSime implements Runnable{
	
	@Override
	public void run() {
		Thread t=Thread.currentThread();
		System.out.println(t);
	}	
}

控制台输出如下

Thread[Thread-0,5,main]
Thread[Thread-0,5,main]

③isAlive方法
作用 判定该线程是否处于就绪、运行或阻塞状态，如果是则返回true，否则返回false。

public class Alive {
	public static void main(String[] args) {
		Thread mainThread = Thread.currentThread();
		Al timeThread = new Al(mainThread);
		//输出false当前的线程对象虽然已经创建，但是还未开启
		System.out.println(timeThread.isAlive());
		timeThread.start();
		//输出true因为timeThread线程有sleep将该线程变为阻塞
		//主线程拿到CPU的执行权
		System.out.println(timeThread.isAlive());
	}
}
class Al extends Thread{
	Thread thread;
	public Al(Thread thread) {
		this.thread = thread;
	}
	@Override
	public void run() {
		//输出为true或false
		//当timeThread线程运行到这里之前主线程拿到CPU的执行权
		//主线程执行完毕变成死亡状态将返回false
		//但当timeThread线程运行到这里主线程未拿到CPU的执行权
		//就会执行下面的代码主线程为就绪状态则会返回true
		System.out.println(thread.isAlive());
		try {
			//阻塞状态10秒
			sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//输出为false，主线程后面的代码很短，当该线程变成阻塞状态
		//主线程拿到执行权，将把剩下的代码执行完毕，变成死亡状态
		//如果在主线程中开启该线程的代码后面把主线程也阻塞
		//并超过10s这里将返回true，上面阻塞前也一定返回true
		System.out.println(thread.isAlive());
	}
}

输出如下

false
true
false
false

④setDaemon方法
作用用于将一个尚未调用线程start方法的线程设置为守护线程。守护线程主要用于为其他线程的运行提供服务（Java中的垃圾回收机制就是守护线程），这种线程属于创建它的线程。
注意：
守护线程随着最后一个非守护线程的终止而终止

public class ShunXv {
	public static void main(String[] args) {
		ZTime timeThread=new ZTime();
		timeThread.setDaemon(true);
		timeThread.start();
		try {
			ZTime.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
class ZTime extends Thread{

	@Override
	public void run() {
		while(true) {
			System.out.println("1111");
		}		
	}	
}

输出如下

如果取消设置，则效果如下

程序不会自动终止，控制台执行死循环while(true);

⑤join()方法
当前线程进入阻塞状态，在调用该方法的线程对象对应的线程结束后，当前线程再由阻塞转为就绪状态。

public class Join {
	
	public static void main(String[] args) {
		TimeThread timeThread = new TimeThread(new CountThread());   //meiyou chuangjianduixiang hui bao exception
		timeThread.start();		
		CountThread countThread = new CountThread();
		countThread.start();	
	}
}
class TimeThread extends Thread{
	CountThread countThread;
	public TimeThread(CountThread countThread) {
		this.countThread=countThread;
	}	
	@Override
	public void run() {
		for(int i=1;i<=5;i++) {
			System.out.println(new java.util.Date());
			try {
				countThread.join();
				sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}	
}
class CountThread extends Thread{
	
	@Override
	public void run() {
		for(int i=1;i<=5;i++) {
			System.out.println("XXXXXXXX"+new java.util.Date());
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}	
}

输出如下，交叉输出

Sun Jun 30 15:27:51 CST 2019
XXXXXXXXSun Jun 30 15:27:51 CST 2019
Sun Jun 30 15:27:52 CST 2019
XXXXXXXXSun Jun 30 15:27:52 CST 2019
Sun Jun 30 15:27:53 CST 2019
XXXXXXXXSun Jun 30 15:27:53 CST 2019
Sun Jun 30 15:27:54 CST 2019
XXXXXXXXSun Jun 30 15:27:54 CST 2019
Sun Jun 30 15:27:55 CST 2019
XXXXXXXXSun Jun 30 15:27:55 CST 2019

⑥start()不能启动多次
Java 虚拟机负责调用该线程的 run() 方法。多次启动一个线程是非法的。
⑦yield
当前线程放弃占用CPU资源，回到就绪状态，使其他优先级不低于此线程的线程有机会被执行。
⑧优先级的问题，如何设置优先级
设置当前线程的优先级，线程优先级越高，线程获得执行的次数越多，Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：
static int MAX_PRIORITY 最高优先级值为10；
static int NORM_PRIORITY 默认优先级值为5；
static int MIN_PRIORITY 最低优先级值为1；

public class youxianji {
	
	public static void main(String[] args) {
		
		RECountThread countThread1=new RECountThread("线程1");
		countThread1.setPriority(10);  //设置优先级
		countThread1.start();
	
		RECountThread countThread2=new RECountThread("线程2");
		System.out.println(countThread2.getPriority());  //获取优先级
		countThread2.start();	
	}
}
class RECountThread extends Thread{
	RECountThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		for(int i=1;i<=5;i++) {
			System.out.println(getName()+"XXXXXXXXX"+i);
		}
	}
	
}

输出如下

5
线程1XXXXXXXXX1
线程1XXXXXXXXX2
线程1XXXXXXXXX3
线程1XXXXXXXXX4
线程1XXXXXXXXX5
线程2XXXXXXXXX1
线程2XXXXXXXXX2
线程2XXXXXXXXX3
线程2XXXXXXXXX4
线程2XXXXXXXXX5