线程的Thread创建方式以及Thread中几种常用方法

本文链接：https://blog.youkuaiyun.com/weixin_42618601/article/details/108314576

Thread创建线程主要分为四步：

创建一个线程类继承于Thread类
在该类中重写Thread的run()方法，该方法中生命线程的操作
在主线程中创建该类的对象
引用start（）方法，启动线程
话不多说，直接上代码：

class MyThread extends Thread{// 1. 创建一个线程类继承于Thread类
      @Override
      public void run(){//2. 在该类中重写Thread的run()方法，该方法中生命线程的操作.重写run方法，输出100以内的偶数
            for（int i=0;i<100;i++）{
                 if(i%2==0){
                       System.out.println(Thread.currentThread.getName()+":"+i)
                 }
            }
      }
}
public class ThreadTest{
      public static void main(String[] args){
           MyThread  myThread=new MyThread();// 3. 在主线程中创建该类的对象
           myThread.start();// 4. 引用start（）方法，启动线程
      }
}

以上代码可以用匿名内部类的方式创建：

public class ThreadTest1{
      public static void main(String[] args){
           new Thread(){
                   @Override
                   public void run(){//2. 在该类中重写Thread的run()方法，该方法中生命线程的操作.重写run方法，输出100以内的偶数
                           for（int i=0;i<100;i++）{
                                  if(i%2==0){
                                        System.out.println(Thread.currentThread.getName()+":"+i)
                                   }
                           }
                   }
           }.start();
      }
}

Thread的几种常用方法：

start():启动当前线程，调用run()方法，start的工作有两步，首先使线程进入准备状态，然后调用run（）方法启动。
run（）：重写Thread中的此方法，声明线程要执行的操作。
currentThread():静态方法，返回当前正在执行代码的线程。
getName（）：获取当前线程名
setName（）：设置当前线程名
yield（）：释放当前线程CPU的执行权，但有可能下一次该线程继续抢占到执行权。
join（）：在线程A中调用线程B的join（）方法，此时线程A进入阻塞状态，直到线程B执行结束才结束阻塞状态。
stop（）：当执行此方法时，强制结束当前线程。该方法现在已经弃用。
sleep（long millitime）：让当前线程睡眠指定的毫秒数，睡眠时间内为阻塞状态。
isAlive（）：判断该线程是否还存活

简单的代码演示一下：

class MyThread extends Thread{
      @Override
      public void run(){// 2. run（）：重写Thread中的此方法，声明线程要执行的操作。
            for（int i=0;i<100;i++）{
                 if(i%2==0){
                       try{
                              sleep(10)// 9. sleep（long millitime）：注意，这里让线程睡眠10毫秒，使用sleep时要抛出异常
                       }catch(InterruptedException e){
                            e.printStackTrace();
                       }
                       System.out.println(Thread.currentThread.getName()+":"+i)// 3. currentThread():输出当前线程的名字 4. getName（）：获取当前线程
                 }
                 if(i%20==0){
                    this.yield();// 6. yield（）：当i=20的倍数时释放当前线程CPU的执行权，但有可能下一次该线程继续抢占到执行权。
                 }
            }
      }
}
public class ThreadTest{
      public static void main(String[] args){
           MyThread  myThread=new MyThread();
           myThread.setName("测试线程方法的线程：")// 5. setName（）：设置当前线程名
           myThread.start();// 1. start():启动当前线程，调用run()方法，start的工作有两步，首先使线程进入准备状态，然后调用run（）方法启动。
           if(i==30){
                  try{
                        myThread.join();// 7. join（）：在主线程中调用分线程的join方法，当主线程的i为30，主线程挂起，分线程执行结束后才结束阻塞状态。
                  }catch(InterruptedException e){
                        e.printStackTrace();
                  }
                   
           }

      }
      System.out.println(myThread.isAlive());//判断子线程是否还存活，输出为false，表示已经销毁。
}