java线程Thread常用方法及守护线程

/**
* Thread类常用方法及守护线程
*/
public class Test6Thread extends Thread{
   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName());
       //Thread类静态方法currentThread()返回当前线程，在线程对象中也可以使用this.getName()得到线程对象的name
   }

   public static void main(String[] args) {
       Test6Thread t1 = new Test6Thread();
       t1.start();
       //结果为：Thread-0 第一个创建的线程的name为0号
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           throw new RuntimeException(e);
       }
       Thread t2 = new Thread(new Test6Thread());
       //Thread(Runnable)构造方法，因为Thread实现了Runnable，所以也可以自己套自己
       t2.start();
       //结果为：Thread-2，因为传入的new Test6Thread()也产生了一个Thread对象Thread-1，而t2.start()后t2线程执行了1号的run方法，currentThread()返回当前执行方法的线程而不是当前run()方法所属的对象
       //Thread类在构造器中设定了新对象的name值，默认使用Thread-序号的格式，每生成一个默认name序号++
       Thread t3 = new Thread(new Test6Thread(),"sfda");
       //构造器中设定t3的name值为sfda
       t3.start();
       //结果为：sfda，但内置的new Test6Thread()的name是Thread-3
       Thread t4 = new Thread(new Test6Thread());
       t4.start();
       //结果为：Thread-5，因为内置的new Test6Thread()为Thread-4
       t4.setName("t4");
       //Thread类的.setName(String name)更改name值
       System.out.println(t4.isAlive());
       //.isAlive()判断线程是否正在运行，处于死亡状态返回false
       try {
           Thread.sleep(3000);
       } catch (InterruptedException e) {
           throw new RuntimeException(e);
       }
       System.out.println(t1.isAlive());
       //结果为：false，t1线程已运行结束变为死亡状态
       Thread t5 = new Thread();
       System.out.println(t5.isAlive());
       //结果为：false，新生状态下线程没有运行，只是一个对象
   }
}

class Test7Thread implements Runnable{
   boolean alive = true;
   int num;
   @Override
   public void run() {
       while (alive){
           num++;
           Thread.yield();
       }
       System.out.println(Thread.currentThread().getName()+"执行次数："+num);
   }
   public void over(){
       alive=false;
       //结束线程
   }

   public static void main(String[] args) {
       Test7Thread run1 = new Test7Thread();
       Test7Thread run2 = new Test7Thread();
       Thread t1 = new Thread(run1,"t1");
       Thread t2 = new Thread(run2,"t2");
       t1.setPriority(Thread.MAX_PRIORITY);
       //.setPriority(int)设定优先级，线程优先级最大MAX_PRIORITY=10
       System.out.println(t2.getPriority());
       //.getPriority()返回当前优先级，默认是NORM_PRIORITY=5
       t2.setPriority(Thread.MIN_PRIORITY);
       //线程优先级最小MIN_PRIORITY=1，优先级的设定必须在启动start之前才生效
       t1.start();
       t2.start();
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           throw new RuntimeException(e);
       }
       run1.over();
       run2.over();
       //结果：
       //t2执行次数：7787259
       //t1执行次数：7761756
       //优先级的设定只是java内的概念，JVM只能将优先级传给操作系统，实际的优先级由操作系统决定
       //结论：没什么用

   }
}

class DaemonThread implements Runnable{
   //测试守护线程
   //java中线程分为用户线程和守护线程，通过对线程设定setDaemon(true)使该线程变为守护线程，其他所有默认false的线程都是用户线程，用户线程是程序里的自定义线程，守护线程是服务其他线程的线程，比如垃圾回收线程，当所有用户线程均已结束，只剩下守护线程时，JVM退出，守护线程随之中断
   @Override
   public void run() {
       while (true){
           System.out.println("守护线程运行中");
           try {
               Thread.sleep(20);
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
           //实现接口的方法在接口中没有设定throws抛出异常则实现方法也不能抛出
       }
   }

   public static void main(String[] args) {
       Thread t = new Thread(new DaemonThread());
       t.setDaemon(true);
       //.setDaemon(boolean)设定守护线程，默认false即用户线程
       t.start();
       //在main线程中启动了守护线程t，main中没有再启动其他用户线程，当main主线程结束（可能存在其他JVM自动生成的用户线程随之结束后），所有用户线程结束，守护线程t随JVM退出而结束
       try {
           Thread.sleep(500);
       } catch (InterruptedException e) {
           throw new RuntimeException(e);
       }
       System.out.println("主线程结束");
       //结果为：
       //守护线程运行中
       //守护线程运行中
       //主线程结束

       //任何子线程都可以启动守护线程，当主线程、子线程等所有用户线程结束后，JVM退出，守护线程结束
   }
}