1、join线程

join() 方法的作用是使线程同步执行，将并发执行变成串行执行

public class JoinTestDemo {public static void main(String[] args) {ThreadJoinTest t1 = new ThreadJoinTest("小明");ThreadJoinTest t2 = new ThreadJoinTest("小东");/*try {//join()方法在start() 方法前并不会起到 线程 同步执行的效果// 所以join() 方法一定要用在 start() 方法之后才有意义t1.join();} catch (InterruptedException e) {e.printStackTrace();}*/t1.start();/**join的意思是使得放弃当前线程的执行，并返回对应的线程，例如下面代码的意思就是：程序在main线程中调用t1线程的join方法，则main线程放弃cpu控制权，并返回t1线程继续执行直到线程t1执行完毕所以结果是t1线程执行完后，才到主线程执行，相当于在main线程中同步t1线程，t1执行完了，main线程才有执行的机会*/try {//t1.join();//join() 方法还可以接受一个参数，表示main 线程只会等待t1线程1秒钟，1秒过后，main 线程和 t1线程之间的执行顺序由串行执行变成并行执行//join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()t1.join(1000);} catch (InterruptedException e) {e.printStackTrace();}t2.start();}
}
class ThreadJoinTest extends Thread{public ThreadJoinTest(String name){super(name);}@Overridepublic void run(){for(int i=0;i<10;i++){System.out.println(this.getName() + ":" + i);}}
}

2、线程睡眠 sleep()方法（）

sleep(long millis) 线程睡眠 millis 毫秒
sleep(long millis, int nanos) 线程睡眠 millis 毫秒 + nanos 纳秒
sleep()是静态方法，使用 Thread.sleep（）的方法调用
线程的sleep方法应该写在线程的run()方法里，就能让对应的线程睡眠
不释放锁

public class SleepTestDemo {public static void main(String[] args) {SleepThread sleepThread = new SleepThread();Thread thread = new Thread(sleepThread);thread.start();for(int i=0;i<3;i++){System.out.println("主线程："+i);}}
}
class SleepThread implements Runnable{@Overridepublic void run() {try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}for (int i = 0; i < 3; i++) {System.out.println("SleepThread : " + i);}}
}

打印结果

主线程：0
主线程：1
主线程：2
---------这里 SleepThread  线程沉睡 5秒钟-------
SleepThread : 0
SleepThread : 1
SleepThread : 2

sleep() 方法 到底是让哪个线程睡眠

sleep方法只能让当前线程睡眠。调用某一个线程类的对象t.sleep()，睡眠的不是t，而是当前线程。，下面代码验证一下

public class SleepTestDemo {public static void main(String[] args) {SleepThread1 sleepThread1 = new SleepThread1();sleepThread1.start();try {//下面这行代码只会让 main 线程睡眠5秒钟，不会使sleepThread1线程睡眠5秒钟，sleep（）方法只能作用于当前线程SleepThread1.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}for(int i=0;i<3;i++){System.out.println("主线程："+i);}}
}
class SleepThread1 extends Thread{@Overridepublic void run() {for (int i = 0; i < 3; i++) {System.out.println("SleepThread1 : " + i);}}
}

打印结果

SleepThread1 : 0
SleepThread1 : 1
SleepThread1 : 2
-----------此处main 线程 睡眠5秒------
主线程：0
主线程：1
主线程：2

sleep 不会释放同步锁

public class SleepTestDemo {public static void main(String[] args) {SleepThread sleepThread = new SleepThread();Thread thread = new Thread(sleepThread);Thread thread1 = new Thread(sleepThread);thread.start();thread1.start();}
}
class SleepThread implements Runnable{@Overridepublic  void run() {syn();}private synchronized  void syn(){System.out.println("线程" + Thread.currentThread().getName()+"获取到monitor。");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("线程" + Thread.currentThread().getName()+"睡眠结束。退出同步代码块");}
}

打印结果

线程Thread-0获取到monitor。
线程Thread-0睡眠结束。退出同步代码块
线程Thread-1获取到monitor。
线程Thread-1睡眠结束。退出同步代码块

控制线程睡眠的方法还有一种：

TimeUnit.SECONDS.sleep(1);
TimeUnit.MINUTES.sleep(1);
TimeUnit.HOURS.sleep(1);
TimeUnit.DAYS.sleep(1);

3、后台线程

后台线程，它是在后台运行的，它的任务是为其他线程提供服务，这种线程被称为“后台线程（Daemon Thread）”,又称为“守护线程”或“精>灵线程”。JVM的垃圾回收线程就是典型的后台线程。
后台线程的特征：如果所有的前台线程都死亡了，后台线程也会自动死亡。

调用Thread对象的setDaemon(true)可将制定线程设置为后台线程。所有的前台线程都死亡时，后台线程也死亡，程序就退出了public class DaemonThreadTest {public static void main(String[] args) {DaemonThread daemonThread= new DaemonThread("后台线程");//设置为后台线程，注意必须在start前掉用，否则会报错！daemonThread.setDaemon(true);daemonThread.start();try {//主线程沉睡睡眠5秒Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("主线程执行完毕");MtThread thread = new MtThread("前台线程");thread.start();}
}public class DaemonThread extends Thread {public DaemonThread(String name){super(name);}@Overridepublic void run(){for(int i=0;i<100;i++){try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName()+"->"+i);}}
}class MtThread extends Thread{public MtThread(String name) {super(name);}@Overridepublic void run() {for(int i = 0 ; i < 5 ; i ++){try {sleep(500);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println(getName() + "   " + i );}System.out.println("前台线程执行完毕");}
}

执行结果，所有的前台线程执行完之后后台线程也死亡

后台线程->0
后台线程->1
主线程执行完毕
前台线程   0
前台线程   1
后台线程->2
前台线程   2
前台线程   3
前台线程   4
前台线程执行完毕

4、线程让步

Thread中有一个线程让步方法yield()，作用就是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！

public class YieldThreadDemo {public static void main(String[] args) {YieldThread yieldThread = new YieldThread("线程一");YieldThread yieldThread2 = new YieldThread("线程二");yieldThread.start();yieldThread2.start();}}class YieldThread extends Thread{public  YieldThread(String name){super(name);}@Overridepublic synchronized void run() {for (int i=0;i<5;i++){System.out.println(Thread.currentThread().getName()+"->"+i+"->"+this.getPriority());if(i%2==0){Thread.yield();}}}
}

说明

“线程一”在能被2整数的时候，并没有切换到“线程二”。这表明，yield()虽然可以让线程由“运行状态”进入到“就绪状态”；但是，它不一定会让其它线程获取CPU执行权(即，其它线程进入到“运行状态”)，即使这个“其它线程”与当前调用yield()的线程具有相同的优先级。在多CPU并行的环境下，yield方法的功能有时候不明显，可能看不到效果。

5、线程优先级

java 中的线程优先级的范围是1～10，1的优先级最低，10的优先级最高。
通过setPriority()方法，可以改变线程的优先级

public class PriorityTest extends Thread
{// 定义一个有参数的构造器，用于创建线程时指定namepublic PriorityTest(String name){super(name);}@Overridepublic void run(){for (int i = 0 ; i < 4 ; i++ ){System.out.println(getName() +  ",其优先级是："+ getPriority() + ",循环变量的值为:" + i);}}public static void main(String[] args){// 改变主线程的优先级Thread.currentThread().setPriority(6);for (int i = 0 ; i < 4 ; i++ ){if (i == 2){PriorityTest low  = new PriorityTest("低级");low.start();System.out.println("创建之初的优先级:"+ low.getPriority());// 设置该线程为最低优先级low.setPriority(Thread.MIN_PRIORITY);}if (i == 3){PriorityTest high = new PriorityTest("高级");high.start();System.out.println("创建之初的优先级:"+ high.getPriority());// 设置该线程为最高优先级high.setPriority(Thread.MAX_PRIORITY);}}}
}