一、线程睡眠：sleep()

当我们想要暂时暂停一个线程的时候，可以调用 Thread.sleep() 方法，传入参数为睡眠时间（单位是毫秒）。另外，这个方法必须处理 InterruptedException，因为线程在睡眠的时候可能被终止。

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         Thread play = new Thread() {
  4.             @Override
  5.             public void run() {
  6.                 int second = 0;
  7.                 while (true) {
  8.                     try {
  9.                         Thread.sleep(1000);
  10.                     }
  11.                     catch (InterruptedException e) {
  12.                         System.out.println(e);
  13.                     }
  14.                     System.out.printf("已经玩了%d秒\n", ++second);
  15.                     if (second >= 20) break;
  16.                 }
  17.             }
  18.         };
  19.         play.start();
  20.     }
  21. }

附：这是 Thread 的一个静态方法，不是类方法

二、线程优先级：setPriority()

程序是无限的，资源是有限的，为了使用有限的资源来尽可能多的完成任务，操作系统引入了线程优先级的概念。优先级越高，系统越会优先将CPU，显卡等宝贵资源分配给这个线程，优先满足它的运行要求。
不知道为啥，大多数操作系统都是只设置了从 1 到 10 的十挡，数字越大，优先级越高，Java 里面也采用了这一概念。

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         Thread play = new Thread();
  4.         play.setPriority(7);//比较高的优先级
  5.         play.setPriority(2);//比较低的优先级
  6.         play.setPriority(Thread.MAX_PRIORITY);//最高优先级
  7.         play.setPriority(Thread.MIN_PRIORITY);//最低优先级
  8.         play.setPriority(Thread.NORM_PRIORITY);//正常优先级
  9.         //设置了不合法的参数，会抛出异常
  10.         try {
  11.             play.setPriority(-1);
  12.         }
  13.         catch (IllegalArgumentException e) {
  14.             System.out.println("参数异常，被驳回");
  15.         }
  16.     }
  17. }

三、线程暂停：yield()

当有时有必要的时候，可以调用这一方法，暂时暂停某个线程，把资源让出来给别人用（或者别的目的）。等到需要的时候，再使用 start() 来开启它。
附：和sleep() 一样，这也是个静态方法。

  1. Thread.yield();

四、守护线程：setDaemon()

有这么一类线程，它们不抛头露面，但是却隐藏在界面背后，默默支撑着程序的运行（例如各类杀软都有很多守护线程，还有 JVM 的垃圾回收线程之类）。
和守护线程相对的是用户线程，这些线程一般直接展示给用户。如果一个程序的用户线程已经不再存在，那么守护线程也就没有了存在必要，也会自动关闭。（打个比方，一个公司的销售，研发部门啥的都是用户线程，财政，保安部门就是守护线程，如果公司倒闭了，销售研发啥的都关闭了，那么财政保安啥的也就没有了服务对象，也会自动关闭）。
这个细究下去能挖一片，例如系统安全，操作系统原理啥的。但是我们暂时不管那么多，只需要知道我们如何设定一个线程的属性即可。

  1. Thread ProtectTask = new Thread();
  2. ProtectTask.setDaemon(true);//设为守护线程
  3. ProtectTask.setDaemon(false);//取消其守护线程的特性

五、加入到目前线程之中

先介绍一下主线程的概念：当前正在运行的线程叫做主线程。
这时候，我们可以执行 其他线程的 join() 方法，这时候这个线程就会插入到这个主线程中开始执行，在这个线程执行结束前，原本的主线程将会被挂起，直到该线程执行完毕后才会继续执行。（当然，这并不影响其他线程的并行）

  1. public class Main {
  2.     public static void main(String[] args) throws Exception {
  3.         Thread cyh = new Thread() {
  4.             @Override
  5.             public void run() {
  6.                 for (int i = 0; i < 7; ++i)
  7.                 System.out.println("cyh");//可以直接用外部的变量哦
  8.             }
  9.         };
  10.         //记得先start
  11.         cyh.start();
  12.         //我的电脑上面，cyh开始了后被暂时挂起，系统依旧在执行main线程
  13.         for (int i = 0; i < 3; ++i)
  14.             System.out.println("jhw");
  15.         //cyh线程加入了，该线程会一直运行下去，直到结束之后才会回到main线程
  16.         cyh.join();
  17.         //cyh线程执行结束之后，系统才回到main线程，继续执行剩下的语句
  18.         for (int i = 0; i < 4; ++i)
  19.             System.out.println("jhw");
  20.     }
  21. }