常用方法
| 方法名 | 说明 |
| public static void sleep(long millis) | 当前线程主动休眠 millis 毫秒。 |
| public static void yield() | 当前线程主动放弃时间⽚，回到就绪状态，竞争下⼀次时间⽚。 |
| public final void join() | 允许其他线程加⼊到当前线程中。 |
| public void setPriority(int) | 线程优先级为1-10，默认为5,优先级越⾼，表示获取CPU机会越多。 |
| public void setDaemon(boolean) | 设置为守护线程线程有两类：⽤户线程（前台线程）、守护线程（后台线程） |
线程的优先级
我们可以通过传递参数给线程的 setPriority() 来设置线程的优先级别
调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运⾏机会。优先级 : 只能反映线程的中或者是紧急程度 , 不能决定 是否⼀定先执行
Java线程的优先级⽤整数表示，取值范围是1~10，Thread类有以下三个静态常量：
static int MAX_PRIORITY
线程可以具有的最⾼优先级，取值为10。
static int MIN_PRIORITY
线程可以具有的最低优先级，取值为1。
static int NORM_PRIORITY
分配给线程的默认优先级，取值为5。示例：
class PriorityThread extends Thread{
@Override
public void run() {
for(int i=0;i<50;i++) {
System.out.println(Thread.currentThread().getName()+"============"+i);
}
}
}
public class TestPriority {
public static void main(String[] args) {
PriorityThread p1 = new PriorityThread();
p1.setName("P1线程");
PriorityThread p2 = new PriorityThread();
p2.setName("P2线程");
PriorityThread p3 = new PriorityThread();
p3.setName("P3线程");
p1.setPriority(Thread.MAX_PRIORITY);
p3.setPriority(Thread.MIN_PRIORITY);
p1.start();
p2.start();
p3.start();
}
}线程的休眠
使⽤线程的 sleep() 可以使线程休眠指定的毫秒数,在休眠结束的时候继续执⾏线程
示例：
class SleepThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("新开的线程："+i);
}
}
}
public class TestSleep {
public static void main(String[] args) {
SleepThread sleepThread = new SleepThread();
sleepThread.start();;
System.out.println("---------------------");
//让当前线程睡眠10秒
try {
Thread.sleep(1000*2);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 10; i++) {
System.out.println("主线程："+i);
}
}
}线程的让步
Thread.yield() ⽅法作⽤是：暂停当前正在执⾏的线程对象（及放弃当前拥有的cup资源），并执⾏其他线程。
yield() 做的是让当前运⾏线程回到可运⾏状态，以允许具有相同优先级的其他线程获得运⾏机会。因此，使⽤ yield() 的⽬的是让相同优先级的线程之间能适当的轮转执⾏。但是，实际中⽆法保证 yield() 达到让步⽬的，因为让步的线程还有可能被线程调度程序再次选中。
class Task1 implements Runnable{
@Override
public void run() {
for (int i = 0;i < 100;i++){
System.out.println("A:"+i);
}
}
}
class Task2 implements Runnable{
@Override
public void run() {
for (int i = 0;i < 10;i++){
System.out.println("B:"+i);
//让步
Thread.yield();
}
}
}
public class TestYield {
public static void main(String[] args) {
// Task1 task1 = new Task1();
// Thread thread = new Thread(task1);
// thread.start();
//匿名对象，这个方法只需要使用一次
new Thread(new Task1()).start();
new Thread(new Task2()).start();
}
}sleep()和yield()的区别
sleep()使当前线程进⼊停滞状态，所以执⾏sleep()的线程在指定的时间内肯定不会被执⾏；
yield()只是使当前线程重新回到可执⾏状态，所以执⾏yield()的线程有可能在进⼊到可执⾏状态后⻢上⼜被执⾏。
sleep ⽅法使当前运⾏中的线程睡眼⼀段时间，进⼊不可运⾏状态，这段时间的⻓短是由程序设定的，yield ⽅法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()⽅法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运⾏状态，如有，则把 CPU的占有权交给此线程，否则，继续运⾏原来的线程。所以yield()⽅法称为“退让”，它把运⾏机会让给了同等优先级的其他线程另外，sleep ⽅法允许较低优先级的线程获得运⾏机会，但 yield() ⽅法执⾏时，当前线程仍处在可运⾏状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在⼀个运⾏系统中，如果较⾼优先级的线程没有调⽤ sleep ⽅法，⼜没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较⾼优先级的线程运⾏结束，才有机会运⾏。
线程的合并
Thread 中， join() ⽅法的作⽤是调⽤线程等待该线程完成后，才能继续往下运⾏。
join是Thread类的⼀个⽅法，启动线程后直接调⽤，即join()的作⽤是：“等待该线程终⽌”，这⾥需要理解的就是该线程是指的主线程等待⼦线程的终⽌。也就是在⼦线程调⽤了join()⽅法后⾯的代码，只有等到⼦线程结束了才能执⾏。
为什么要⽤join()方法
在很多情况下，主线程⽣成并起动了⼦线程，如果⼦线程⾥要进⾏⼤量的耗时的运算，主线程往往将于⼦线程之前结束，但是如果主线程处理完其他的事务后，需要⽤到⼦线程的处理结果，也就是主线程需要等待⼦线程执⾏完成之后再结束，这个时候就要⽤到 join() ⽅法了。
示例：
class JoinThread extends Thread{
public JoinThread(String name){
super(name);
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"打印---->"+i);
}
}
}
public class TestJoin {
public static void main(String[] args) {
System.out.println("主线程开始执行.....");
JoinThread joinThread = new JoinThread("新加入的线程");
joinThread.start();
try {
joinThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("主线程结束执行.....");
}
}
