1. start 启动线程 执行run方法
    2. setName,getName 设置、获取线程名称
    3. currentThreadd() 返回执行当前代码的线程
    4. yieid() 是否当前cpu执行权; 但是还是有可能抢到执行权
    5. sleep() 阻塞当前线程 单位毫秒
    6. join 线程A中使用线程B调用join方法 此时线程A阻塞 等待线程B执行完毕后 线程A继续执行

    7. isAlive 判断当前线程是否还存活 ```java /**

      • 创建人:LYY
      • 创建时间:2022/4/25

      • 线程常用的方法 */ public class ThreadMethod {

        public static void main(String[] args) {

        ThreadOne threadOne1 = new ThreadOne(); try {

        1.    // 设置当前线程名称
        2.    Thread.currentThread().setName("主线程:");
        4.    // 设置线程名称
        5.    threadOne1.setName("线程一:");
        6.    // 启动线程 执行操作
        7.    threadOne1.start();
        8.    // 主线程执行
        9.    for (int i = 0; i < 100; i++) {
        10.        if (i % 2 != 0) {
        11.            System.out.println(Thread.currentThread().getName() + "i = " + i);
        12.        }
        13.        if (i == 23) {
        15.            // 释放当前线程cpu的执行权; 但是可能还会抢到执行权
        16.            threadOne1.yield();
        17.        }
        18.        if (i == 29) {
        20.            // 判断当前线程是否还存活
        21.            boolean alive = threadOne1.isAlive();
        22.            // A线程中调用B线程 此时阻塞A线程 直至B线程执行完成后 A线程继续执行
        23.            threadOne1.join();
        25.        }
        26.    }
    1.     } catch (InterruptedException e) {
    2.         e.printStackTrace();
    3.     }
    4. }

    }

    1. ```java
    2. /**
    3.  * 创建人:LYY
    4.  * 创建时间:2022/4/25
    5.  *
    6.  * 多线程创建方式一:
    7.  *  1. 创建一个继承Thread类的子类
    8.  *  2. 重写Thread类的run方法
    9.  *  3. 将要执行的内容写在run方法体内
    10.  *  4. 通过对象调用当前子类的start方法
    11.  */
    12. public class ThreadOne extends Thread{
    14.     @Override
    15.     public void run() {
    17.         // 输出1-100的偶数
    18.         for (int i = 0; i < 100; i++) {
    19.             if (i % 2 == 0) {
    20.                 System.out.println(this.getName() + "i = " + i + "**");
    21.             }
    22.             if (i == 50) {
    24.                 // 睡眠(阻塞)3秒后执行
    25.                 try {
    26.                     sleep(3000);
    27.                 } catch (InterruptedException e) {
    28.                     e.printStackTrace();
    29.                 }
    30.             }
    31.         }
    32.     }
    33. }