结束(stop)

//线程正常停止 //使用标志位 //不要使用stop，destroy

public class TestStop implements Runnable {
    private boolean flag=true;

    @Override
    public void run() {
        int  i=0;
        while (flag){
            System.out.println("run thread"+i++);
        }
    }

    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {
        TestStop testStop=new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==900){
                testStop.stop();
                System.out.println("线程停止");
            }

        }

    }
}

线程休眠（sleep）

指定当前线程阻塞的毫秒数 存在异常interruptionException 时间到达后进入就绪状态 sleep模拟网络延迟

public class TestSleep2 {


    public static void main(String[] args) {
//        try {
//            tenDown();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

        try {
            getTime();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //倒计时
    public static void tenDown () throws InterruptedException {
        int num=10;
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0)
                break;
        }
    }
    //时钟
    public static void getTime () throws InterruptedException {
        int num=10;
        while(true){
            Thread.sleep(1000);
            System.out.println(DateUtil.date(new Date(System.currentTimeMillis())));
            num--;
            if (num<=0)
                break;
        }
    }
}

线程礼让(yied)

让当前运行的线程暂停，不阻塞 不一定成功

public class TestYield {
    public static void main(String[] args) {
        MyYield myYield=new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止运行");
    }
}

线程强制执行(join)

合并线程，等该线程执行完毕后，再执行其他线程，类似插队

public class TestJoin implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin=new TestJoin();
        Thread thread= new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 500; i++) {
            if (1==200){
                thread.join();
            }
            System.out.println("Main"+i);
        }
    }
}

线程观察状态

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("/////////");
            }
        });

        Thread.State state=thread.getState();
        System.out.println(state); //NEW

        thread.start();
        state=thread.getState();
        System.out.println(state);//RUN

        while(state != Thread.State.TERMINATED){
            Thread.sleep(100);
            state=thread.getState();
            System.out.println(state);//输出状态
        }
    }
}

线程优先级

java提供线程调度器监控从程序中启动后进入就绪状态的所有线程，线程调度器按照优先级执行 Thread.MIN_PRIORITY=1; Thread.MAX_PRIORITY=10; Thread.NORM_PRIORITY=5; 使用getPriority改变线程优先级 setPriority(int a) //线程优先级

public class TestPriority {
}
class MyPriority implements Runnable{
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());
        MyPriority myPriority=new MyPriority();
        Thread t1=new Thread(myPriority);
        Thread t2=new Thread(myPriority);
        Thread t3=new Thread(myPriority);
        Thread t4=new Thread(myPriority);
        Thread t5=new Thread(myPriority);

        t1.start();
        t2.setPriority(1);
        t2.start();
        t3.setPriority(Thread.NORM_PRIORITY);
        t3.start();
        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();
        t5.setPriority(11);
        t5.start();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());
    }
}

守护线程 daemon

线程分为用户线程和守护线程 虚拟机必须等待用户线程执行完毕 不需等待守护线程 守护线程如：日志记录、内存监控、垃圾回收

public class TestDeamon {
    public static void main(String[] args) {
        God god=new God();
        You you=new You();

        Thread thread1=new Thread(god);
        thread1.setDaemon(true);
        thread1.start();

        Thread thread2=new Thread(you);
        thread2.start();
    }
}

class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("过日子");
        }
        System.out.println("bye");
    }
}
class God implements  Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("神");
        }
    }
}

线程同步

多线程操作同一个资源 进入对象的等待池形成队列