线程中的一些方法

刚学线程两天，决定对线程中的一些方法的调用和调用后的情况进行个人的理解总结，记录一下。

isAlive方法和getState方法

isAlive方法：可以判断当前线程是否存活（当线程状态为NEW或TERMINATED的时候，线程会返回false）
getState方法：返回当前线程的状态

public class IsAlive {
	public static void main(String[] args) {
		Thread x1 = new Thread("t1") {
			@Override
			public void run() {
				try {
					sleep(10000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		};
		x1.start();
		System.out.println(x1.isAlive());
		System.out.println(x1.getState());
	}
}

代码运行结果如下图所示：

interrupt方法、isInterrupted方法、interrupted方法

interrupt方法：如果一个线程处于阻塞状态，通过改变一个interrupted status的状态值来检测当前线程是否应该打断，一旦检测这个状态值为true，将会结束阻塞状态，并且把这个状态值变为flase。

public class Interrupt {
	public static void main(String[] args) {
		Thread x1 = new Thread() {
			@Override
			public void run() {
				try {
					Thread.sleep(10000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		};
		x1.start();
		x1.interrupt();
	}
}

运行效果如下

运行结果看出，当线程x1开始运行，调用interrupt方法后，会把状态值改为true，当线程调用sleep方法进入阻塞状态的时候，会先查看当前线程x1中的状态值是不是为true，如果为true就会打断阻塞的状态，为false的话就不会打断阻塞状态，进入睡眠。
通过源码可以查看interrupt方法的实现如下：

从源码可以看出interrupt实际上是调用了interrupt0方法，而interrupt0实际上是本地方法也无法查看
isInterrupted方法：它的值只有两个，true或者false，它可以用来检测当前的线程的interrupted status状态值是啥。

public class IsInterrupted {
	public static void main(String[] args) {
		Thread x1 = new Thread() {
			@Override
			public void run() {
				try {
					sleep(10000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		};
		x1.start();
		//x1.interrupt();
		System.out.println(x1.isInterrupted());
	}
}

运行如下：

当我们加上x1.interrupt();把interrupteid status状态值变为true的时候，再运行代码时，效果如下：

interrupted方法:这个方法为Thread类中的静态方法，这个方法会返回当前线程的interrupteid status状态值，同时会把这个状态值变为flase。

public class Interrupted {
	public static void main(String[] args) {
		Thread x1 = new Thread() {
			@Override
			public void run() {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				this.interrupt();
				System.out.println(this.isInterrupted());
				System.out.println(Thread.interrupted());
				System.out.println(this.isInterrupted());
			}
		};
		x1.start();
	}
}

运行结果如下：

join方法：它的作用是对于线程中的执行顺序，可以在一个线程中加入另外线程的join方法，其意思在于当前线程执行得在指定的线程执行后面，等待其执行完才可以执行，也可以调用join传方法进来，也就是等待一个线程五秒然后执行。

package Method;

public class Join {
	public static int a;
	public static int b;
	public static void main(String[] args) {
		Thread x1 =new Thread("t1") {
			@Override
			public void run() {
				try {
					Thread.sleep(5000);
					//我们将t1线程睡眠时间久点，看看join有参方法的作用
					//Thread.sleep(50000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				a =(int)(Math.random()*10);
				System.out.println("a="+a);
				System.out.println("t1线程执行完毕");
			}
		};
		Thread x2 = new Thread("t2") {
			@Override
			public void run() {
				try {
					x1.join();
					//等待t1线程一秒钟，一秒钟以后就继续争夺cpu执行权
					//x1.join(1000);
					Thread.sleep(5000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				b =(int)(Math.random()*10);
				System.out.println("b="+b);
				System.out.println("t2线程执行完毕");

			}
		};
		x1.start();
		x2.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(x1.getState());
		System.out.println(x2.getState());
		
	}
}

运行结果如下图所示：

t1线程正处于睡眠状态，处于有限期的等待状态，而t2线程加入了t1.join方法，等待t1线程的结束，所以处于无限期的等待。而当我给t1.join方法传参进来有意延迟t1的睡眠时间让t2等t1一秒然后去抢夺cpu执行权的时候，这时候t2的状态的有限期的等待。

wait、notify、notifyAll方法：这三个方法，属于Object的方法，所有对象都继承了Object，所以对象都可以调用，但是调用的代码块必须给加上锁才能调用。wait方法的作用就是使当前线程从运行状态立马交出cpu的使用权，并且立马进去等待池，使其变为阻塞状态`

package Method;

public class Wait {
	public static int a;
	public static void main(String[] args) {
		Thread x1 =new Thread("t1") {
			@Override
			public void run() {
				synchronized (this) {
		
				try {
					this.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				a =(int)(Math.random()*10);
				System.out.println("a="+a);
				System.out.println("t1线程执行完毕");
			}
			}
		};
		x1.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(x1.getState());
		
	}
}

运行结果如下：

当前线程会进入等待池。
notify方法：这个方法的作用就是释放当前需要这个锁的一个线程的状态，当需要这个锁的线程进入了等待池等待的话，会立马从等待池进入锁池，并监视这个锁可用不，一旦抢到锁就将会进入就绪状态。
notifyAll方法：原理相同 ，只不过它是释放等待池中等待这个锁的所有线程。
（代码就不打了，偷个懒0.0）
yield方法(Thread中的静态方法)：当一个线程进入运行状态后，如果运行时调用了yield方法，那么这个线程就会让出当前执行权，进入就绪状态。但是注意的是，yield方法的调用是不会释放锁的。
setPriority(参数)方法：设置线程的优先级，当然这是概率事件，并不是说优先级高的一定先执行，但是大概率是先执行，如果没有设置优先级，那么默认创建的线程优先级跟当前线程一直，main的优先级为5，参数的传入，Thread类中是定义了三个静态常量来表示线程的优先级的MIN_PRIORITY，NORM_PRIORITY，MAX_PRIORITY，优先度分别为1，5，10。
getPriority方法：返回当前线程的优先度值
（偷个懒=.=完结）