Thread常用方法
join
当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到被join()方法加入的join线程执行完为止。
void join()
等待该线程终止。
void join(long millis)
等待该线程终止的时间最长为 millis 毫秒。
void join(long millis, int nanos)
等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
public class Test {
public static void main(String[] args) {
Thread thread = new MyRunner3();
thread.start();
try {
//主线程等待thread的业务处理完了之后再向下运行
//thread和主线程合并了
//Thread要先启动在join
thread.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for(int i = 0; i < 100; i++){
System.out.println("main : " + i);
}
}
}
class MyRunner3 extends Thread {
@Override
public void run() {
for(int i = 0; i < 5; i++){
System.out.println("i am " + getName());
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
Join()是通过wait函数实现的主线程阻塞。
//源码
public final void join() throws InterruptedException {
join(0);
}
public final synchronized void join(long millis) throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
sleep
Sleep(long)让出cpu的使用权，不释放锁 Wait（long）让出cpu使用权，并释放锁。
static void sleep(long millis)
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
static void sleep(long millis, int nanos)
在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
public class TestThread {
final static Object syn = new Object();
public static void main(String[] args) {
// TODO Auto-generated method stub
new Thread(){
public void run() {
System.out.println(getName()+"等待获取锁。。。。。。。。。。。");
synchronized (syn) {
System.out.println(getName()+"获取到锁。。。。。。。。。。。");
System.out.println(getName()+"进入睡眠状态。。。。。。。。。。。");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(getName()+"睡眠完毕。。。。。。。。。。。");
}
}
}.start();
new Thread(){
public void run() {
System.out.println(getName()+"等待获取锁。。。。。。。。。。。");
long time = System.currentTimeMillis();
synchronized (syn) {
System.out.println(getName()+"获取到锁,已过去"+(System.currentTimeMillis()-time)+"。。。。。。。。。。。");
System.out.println(getName()+"Do Somethings。。。。。。。。。。。");
}
}
}.start();
}
}
//---------输出-------------------------------
Thread-0等待获取锁。。。。。。。。。。。
Thread-0获取到锁。。。。。。。。。。。
Thread-0进入睡眠状态。。。。。。。。。。。
Thread-1等待获取锁。。。。。。。。。。。
Thread-0睡眠完毕。。。。。。。。。。。
Thread-1获取到锁,已过去10001。。。。。。。。。。。
Thread-1Do Somethings。。。。。。。。。。。
yield-线程让步
yield()方法和sleep()方法有点相似，它也是Thread类提供的一个静态方法，它也可以让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程转入到就绪状态。即让当前线程暂停一下，让系统的线程调度器重新调度一次，完全可能的情况是：当某个线程调用了yield()方法暂停之后，线程调度器又将其调度出来重新执行。
实际上，当某个线程调用了yield()方法之后，只有优先级与当前线程相同或者比当前线程更高的处于就绪状态的线程才会获得执行机会。
sleep()与yield()方法区别：
- sleep()方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但yield()方法只会给优先级高或者相同的线程机会
- sleep()方法会将线程转入到阻塞状态，知道经过阻塞时间才会转入就绪状态；而yield()不会将线程转入阻塞状态，它只是强制当前线程进入就绪状态。因此完全有可能某个线程调用了yield()方法暂停之后，立即再次获取处理器资源被执行。
- sleep()方法声明抛出InterruptedException异常，所以嗲用sleep()方法时要么捕捉该异常，要么显示声明抛出该异常；而yield()方法则没有声明抛出任何异常。
- sleep()方法比yield()方法更好的可移植性，通常不建议使用yield()方法来控制并发线程执行。
currentThread
static Thread currentThread()
返回对当前正在执行的线程对象的引用。
优先级
线程的优先级用数字表示，范围从1到10，默认的是为5
每个线程默认的优先级与创建它的父线程的优先级相同
优先级越高的线程，被执行的顺序就比较靠前，
在Thread中存在三个常量：
MAX_PRIORITY
MIN_PRIORITY
NORM_PRIORITY
int getPriority()
返回线程的优先级。
void setPriority(int newPriority)
更改线程的优先级。
守护线程
在B线程中调用A.setDaemon(true)，将A设置为B线程的守护线程，A线程随B线程的消亡而消亡
void setDaemon(boolean on)
将该线程标记为守护线程或用户线程。
