一，休眠线程
public static void sleep(long millis) throws InterruptedException
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。
参数：millis - 以毫秒为单位的休眠时间。
抛出：InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。
package com.yy.threadmethod;
public class Demo3_Sleep {
/**
*
*当父亲坏了，那么，儿子不能比父亲更坏
*当父亲没坏，儿子如果有坏的东西，必须自己去处理
*
* public static void sleep(long millis)
* throws InterruptedException在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。
*
* 参数：millis - 以毫秒为单位的休眠时间。
* 抛出：InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。
*
* */
public static void main(String[] args) throws InterruptedException {
demo1(); //创建一条线程，对其进行睡眠，使其每秒打印一次
demo2(); //创建两条线程，分别进行睡眠，让两条线程交替输出
}
private static void demo2() {
new Thread(){ //父类Thread类里面的run方法是没有throw抛异常的，子类在重写父类的方法的时候，就不能去抛异常，这里只能抓异常surround
public void run(){
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "......aaaaaa");
}
}
}.start();
//开启一条线程
new Thread(){
public void run(){
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "......bbbb");
}
}
}.start();
//开启另一条线程
}
private static void demo1() throws InterruptedException {
for (int i = 20; i >= 0; i--) {
System.out.println("倒计时：" + i + "秒");
Thread.sleep(100);
}
}
}
二，守护线程
守护线程：设置一个线程为守护线程，该线程不会单独执行，当其他的非守护线程都结束后，自动退出，退出的时候会有一定的缓冲时间，不会立马就结束；
public final void setDaemon(boolean on)
将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。
参数：on - 如果为 true，则将该线程标记为守护线程。
被标记成守护线程的线程，相当于象棋里的車马象士，而没被标记为守护线程的线程，相当与将帅。
package com.yy.threadmethod;
public class Demo4_Daemon {
/**
* 守护线程
* 设置一个线程为守护线程，该线程不会单独执行，当其他的非守护线程都结束后，自动退出，退出的时候会有一定的缓冲时间，不会立马就结束
*
* */
public static void main(String[] args) {
Thread t1 = new Thread(){ //匿名内部类
public void run(){ //重写run()方法
for (int i = 0; i < 2; i++) {
System.out.println(getName() + "...wsq" );
}
}
};
Thread t2 = new Thread(){
public void run(){
for (int i = 0; i < 50; i++) {
System.out.println(getName() + "...yy" );
}
}
};
t2.setDaemon(true); //当传入true就是意味着设置为守护线程，把t2设置成守护线程，相当于象棋中的車马象士，去守护t1，ti就相当于是将帅’
t1.start();
t2.start();
}
}
三，加入线程
join()：当前线程暂停，等待指定的线程执行结束之后，当前线程再继续
join(int)：join()的一个重载方法，可以等待指定的毫秒之后继续
- public final void join()
throws InterruptedException等待该线程终止。 抛出：
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。public final void join(long millis,int nanos)
throws InterruptedException等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。- 参数：
millis - 以毫秒为单位的等待时间。
nanos - 要等待的 0-999999 附加纳秒。 - 抛出：
IllegalArgumentException - 如果 millis 值为负，则 nanos 的值不在 0-999999 范围内。
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。
package com.yy.threadmethod;
public class Demo5_Join {
public static void main(String[] args) {
final Thread t1 = new Thread(){ //匿名内部类(局部内部类)在使用它所在方法中的局部变量的时候，必须用final修饰
public void run(){
for (int i = 0; i < 10; i++) {
System.out.println(getName() + "..." + "海阔天空");
}
}
};
Thread t2 = new Thread(){
public void run(){
for (int i = 0; i < 10; i++) {
if(i == 2){ //当i=2时，也就是t2执行两次之后，t1线程开始插队
try {
// t1.join(); //这表示t1线程开始插队，然后，直到t1线程运行完毕后，才轮到t2线程运行
t1.join(1); //这表示t1线程插队，插队1毫秒之后，两条线程继续交替进行，也就是继续多线程进行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(getName() + "..." + "光辉岁月");
}
}
};
t1.start();
t2.start();
}
}
四，礼让线程
yield:礼让线程，让出CPU
public static void yield() 暂停当前正在执行的线程对象，并执行其他线程。
package com.yy.threadmethod;
public class Demo6_Yield {
public static void main(String[] args) {
new MyThread().start(); //定义一条线程
new MyThread().start(); //定义另一条线程
}
}
class MyThread extends Thread{
public void run(){
for (int i = 1; i <= 1000; i++) {
if(i % 10 == 0){ //若i是10的倍数
Thread.yield(); //让出CPU,让另一条线程进行
}
System.out.println(getName() + "..." + i);
}
}
}