线程中常见的方法

1.sleep 休息/延迟

public class TestSleep {
    public static void main(String[] args) {
        My01 my01=new My01();
        Thread t1=new Thread(my01,"线程A");
        t1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main========="+i);
        }

    }
}
class My01 implements  Runnable{

    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            try {
                Thread.sleep(200);//0.2秒 模拟网络延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"===="+i);

        }
    }
}

2.yield

当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片

如果有两个线程，一个cpu，如果a拿到了cpu他会放弃，继续参与两者之间的获取

public class TestYield {
    public static void main(String[] args) {
        YieldThread y1=new YieldThread();
        YieldThread y2=new YieldThread();
        y1.start();
        y2.start(); //y1和y2交替的执行概率会高。
    }
}
class YieldThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"========="+i);
            Thread.yield();
        }
    }
}

3.join

 public final void join()
      允许其他线程加入到当前线程中

其他线程加入到当前线程中那么当前线程就会等着其他线程运行结束，才会运行当前线程

public class TestJoin {
    public static void main(String[] args) throws Exception{
        JoinThread t1=new JoinThread();
        t1.start();
        JoinThread t2=new JoinThread();
        t2.start();

        t1.join();//表示t1线程加入当前main线程中，main线程需要等t1线程执行完毕后才会执行。
        t2.join();
        for (int i = 0; i <20 ; i++) {
            System.out.println("main=========="+i);
        }
    }
}
class JoinThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"============"+i);
        }
    }
}

4.setPriority()

线程对象.setPriority()

线程优先级1-10，默认为5，优先级越高，表示获取cpu的概率越高

public class TestPriority {
    public static void main(String[] args) {
        MyPriority m=new MyPriority();
        Thread t1=new Thread(m,"线程A");
        Thread t2=new Thread(m,"线程B");
        Thread t3=new Thread(m,"线程C");
//        t1.setPriority(1);
//        t2.setPriority(5);
//        t3.setPriority(10); //t3优先级最大 它获取cpu的概率更高
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyPriority implements  Runnable{

    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"========"+i);
        }
    }
}

5. setDaemon(true)

守护线程:
     线程对象.setDaemon(true);设置为守护线程。
     线程有两类:用户线程（前台线程）和守护线程（后台线程）
     如果程序中所有前台线程都执行完毕了，后台线程也会自动结束。
     垃圾回收线程属于守护线程。

public class TestDeamon {
    public static void main(String[] args) {
        My m=new My();
        My2 m2=new My2();
        m.setDaemon(true); //设置m为守护线程  当主线程结束了那么m线程也会结束
        m2.start(); //前台线程
        m.start();
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"======="+i);
        }
    }
}
class My extends  Thread{
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"======="+i);
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class My2 extends  Thread{
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"======="+i);

        }
    }
}