day22 JavaSe之线程

获取线程的优先级
public final int getPriority()返回此线程的优先级。
设置线程的优先级
public final void setPriority(int newPriority)更改此线程的优先级
参数newPriority的范围为1-10之间
newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY
总结：
1、线程的默认优先级为5
2、线程优先级的范围是1-10
3、线程优先级高仅仅表示的是获取CPU时间片的几率会高一些，但是不是绝对一定会获取

public class ThreadPriorityDemo {
    public static void main(String[] args) {
        MyPriorityThread t1 = new MyPriorityThread();
        MyPriorityThread t2 = new MyPriorityThread();

        //获取t1和t2的优先级
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());


        //IllegalArgumentException
        t1.setPriority(1);
        t2.setPriority(10);

        t1.start();
        t2.start();

    }
}

public class MyPriorityThread extends Thread  {
    @Override
    public void run() {
        for(int i =0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

线程休眠

public class ThreadSleepDemo {
    public static void main(String[] args) {
        MySleepThread t1 = new MySleepThread();
        MySleepThread t2 = new MySleepThread();
        MySleepThread t3 = new MySleepThread();

        t1.setName("AA");
        t2.setName("BB");
        t3.setName("CC");

        t1.start();
        t2.start();
        t3.start();
    }
}

public class MySleepThread extends Thread {
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
        try {
            Thread.sleep(1000);

            //加入休眠方法
            //睡一秒钟，1秒=1000毫秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


}

加入线程
public final void join()：其他线程等待这个线程死亡
注意事项：
在线程设置为加入线程之前，先将该线程变为就绪状态，也就是调用start()方法

public class ThreadJoinDemo {
    public static void main(String[] args) {
        MyJoinThread mt1 = new MyJoinThread();
        MyJoinThread mt2 = new MyJoinThread();
        MyJoinThread mt3 = new MyJoinThread();

        mt1.setName("AA");
        mt2.setName("BB");
        mt3.setName("CC");

        mt1.start();

        try {
            mt1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        mt2.start();
        mt3.start();


    }
}

public class MyJoinThread extends Thread {
    @Override
    public void run() {
        for(int i =0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

礼让线程
public static void yield()
暂停当前正在执行的线程对象，并执行其他线程
它的作用是为了让多个线程之间更加和谐一点，并不能一定保证多个线程一人一次执行an

public class ThreadYieldDemo {
    public static void main(String[] args) {
        MyYieldThread t2 = new MyYieldThread();
        MyYieldThread t1 = new MyYieldThread();
       

        t1.setName("小虎");
        t2.setName("冯提莫");

        t1.start();
        t2.start();


    }
}

public class MyYieldThread extends Thread {
    @Override
    public void run() {
        for(int i =0;i<100;i++){
            System.out.println(getName()+":"+i);
            Thread.yield();
        }
    }
}

守护线程
后台线程：（守护线程）

    Java中有两类线程：用户线程、守护线程

    用户线程：我们在学习多线程之前所有程序代码，运行起来都是一个个的用户线程。

    守护线程：所谓的守护线程，指的就是程序运行的时候在后台提供了一种通用服务的线程。比如说
        垃圾回收线程，它就是一个称职的守护者，并且这种线程并不属于程序不可或缺的部分。所以
        非守护线程结束的时候，程序也就终止了，同时会杀死进程种所有的守护线程。
        反过来说，只要程序种存在非守护线程，程序就不会终止。

        守护线程怎么去设置呢？
        public final void setDaemon(boolean on)
        通过这个方法将该线程对象标记为守护线程或者非守护线程。
        当运行的程序只有一个线程且是守护线程的时候，Java虚拟机退出

        注意：
            将线程设置为守护线程这一步骤，必须在启动前设置

public class ThreadDaemonDemo {
    public static void main(String[] args) {
        MyDaemonThread t1 = new MyDaemonThread();
        MyDaemonThread t2 = new MyDaemonThread();
        MyDaemonThread t3 = new MyDaemonThread();

        t1.setName("小虎");
        t2.setName("夏天");
       t2.setDaemon(true);
        t3.setName("陈俊荣");
        t3.setDaemon(true);

        t1.start();
        t2.start();
        t3.start();
    }
}

public class MyDaemonThread extends Thread {
    @Override
    public void run() {
        for(int i =0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

中断线程：
public final void stop():让正在运行的线程停止,run方法剩下的代码不会执行，这个方法过时了，被弃用了，但是还能使用。
public void interrupt():中断正在运行的线程，被中断的线程将run方法执行完毕，并抛出异常
java.lang.InterruptedException: sleep interrupted

public class ThreadStopDemo {
    public static void main(String[] args) {
        MyStopThread t1 = new MyStopThread();

        t1.start();

        try {
            Thread.sleep(3000);
//            t1.stop();
            t1.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }



    }
}

public class MyStopThread extends Thread {
@Override
public void run() {
System.out.println(“开始执行时间：” + new Date());

    try {
        Thread.sleep(10000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println("结束时间：" + new Date());
    System.out.println("hello");


}

}
多线程的实现方式2：
实现Runnable接口
1、创建自定义类实现Runnable接口
2、重现run()方法
3、创建自定义类的对象
4、创建Thread类的对象，将第三步创建的自定义类对象作为参数传递到构造方法中

public class MyRunnableDemo1 {
    public static void main(String[] args) {
        //创建自定义类的对象
        MyRunnbale1 myRunnbale1 = new MyRunnbale1();

        Thread t1 = new Thread(myRunnbale1);
        Thread t2 = new Thread(myRunnbale1);

        t1.setName("小花");
        t2.setName("朱丹");
        t1.start();
        t2.start();

    }
}

public class MyRunnbale1 implements Runnable {
    @Override
    public void run() {
        for (int i =1;i<=100;i++){
            //由于实现的Runnable接口中并没有getName()方法，所以这里无法使用Thread类中的
            //getName()方法
            //间接调用，因为currentThread()是静态的，可以直接通过类名调用获取当前正在
            //执行run方法的线程对象（Thread类型），所以可以调用getName()
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}