javase：多线程

线程生命周期

线程API

ThreadAPIExample.java
线程优先级
1.线程优先级用数字表示：1-10，默认优先级为5
2.API
①int getPiority()//获取优先级
②void setPriority(int) //设置优先级
3.优先级常量
①Thread.MAX_PRIORITY=10
②Thread.MIN_PRIORITY=1
③Thread.NORM_PRIORITY=5
注意：线程优先级只是在JVM有效，线程根本执行在操作系统。所有线程设置的级别，不能决定线程是否根据优先级执行

线程休眠

1.线程休眠：让线程休息，即是让当前线程由运行状态进入到阻塞状态，进而使其他线程有机会继续执行任务。虽然使线程休眠但并不释放对象锁，所以说如果在同步块中使用sleep()，其他线程仍然无法获得执行权
2.API：static void sleep(long millis)线程休眠 long millis休眠时间 单位:毫秒
3.总结
①sleep()是静态方法，可以直接调用
②sleep方法使线程由运行状态转化为休眠阻塞状态
③sleep()并不会释放对象锁

线程让步

1.线程让步：让当前线程休息一会，即让当前线程由运行状态(Running)进入到可运行状态（Runnable），线程让步不释放对象锁。其他线程仍然获取不到锁，需要等待当前线程执行完之后才能获取锁执行任务
2.API：static void yield() 暂停当前正在执行的线程对象，并执行其他线程
3.总结
①yield()方法是静态方法，可直接调用
②yield()方法并没有释放对象
③yield()会使线程由运行时状态转化到可运行状态

package ThreadDemo;

public class ThreadSleepDemo {

    public static void main(String[] args) {

        Thread2 t1 = new Thread2();
        t1.setName("线程A");
        t1.start();

        Thread2 t2 = new Thread2();
        t2.setName("线程B");
        t2.start();

    }
}

class Thread2 extends Thread{

    public Thread2(){
    }

    public Thread2(String name){
        super(name);
    }

    @Override
    public void run(){
        while(true){
            //线程休眠
            String name = Thread.currentThread().getName();
            //if("线程A".equals(name)){
                try {
                    Thread.sleep(1000);//休眠时间 1s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            //}
            System.out.println(Thread1.currentThread().getName()+"----t1----");
        }
    }
}

线程串行

1.线程串行：当前线程等待子线程执行完毕后，才能继续执行
2.API：①void join() 等待该线程终止
②void join(long millis)等待该线程终止的时间最长为millis毫秒
3.总结：
①join()方法本质上是通过wait()方法实现阻塞的
②如果子线程没有启动或者子线程执行结束，主线程不用等待可以继续执行
线程终止

package ThreadDemo;

public class ThreadJoinDemo {

    public static void main(String[] args) throws InterruptedException {
        JoinThread t1 = new JoinThread();

        t1.start();
        t1.setName("线程A");
        t1.join();//t1是子线程 t1没有执行完，main()不会执行
        System.out.println("main");
    }

}
class JoinThread extends Thread{
    @Override
    public void run(){
        int i = 0;
        while(i < 5){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Hello World");
            i++;
        }
    }
}

线程终止

当前线程完成任务后，返还资源，进入死亡状态

线程终止方式

①void stop();用来终止线程。但是该方法终止线程，并不是释放对象锁，容易造成死锁，已淘汰
②采用标记的方式
（1）提供boolean类型
（2）提供getter和setter方法
（3）在循环中使用该属性作为条件
（4）在创建对象资源时设置属性为true
③采用守护线程方式
守护线程：为了帮助主线程完成功能而提供的一个辅助线程，主线程终止辅助线线程也必须终止
void setDanmon(boolean on) 设置当前是否为守护线程，默认为false

package ThreadDemo;

public class ThreadStopDemo {
    public static void main(String[] args) throws InterruptedException {
        ThreadStop t1 = new ThreadStop();
        t1.setFlag(true);
        t1.start();
        Thread.sleep(2000);
        t1.setFlag(false);
        System.out.println("main");
    }
}

class ThreadStop extends Thread{
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    private boolean flag;
    @Override
    public void run(){
        while(flag){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Hello World");
        }
    }
}