# 多线程的创建和使用1. 多线程的创建方式一：继承 Thread 类创建一个继承于 Thread 类的子类重写

1. 多线程的创建

方式一：继承 Thread 类

创建一个继承于 Thread 类的子类
重写 Thread 类的的 run() 方法 ——> 将此线程的操作声明在 run() 中
创建 Thread 类的子类的对象

通过此对象调用 start()

package October_14;

// 1. 创建继承了 Thread 类的子类 MyThead
class MyThread extends Thread {
    @Override
    // 2. 重写了 run() 方法
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

public class uesThread {
    public static void main(String[] args) {
        // 3. 创建子类 MyThead 的对象
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        // 4. 通过对象调用 start() 方法
        myThread1.start();

        // 测试线程之间的并发执行
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i+"main");
            }
        }
    }
}

提示：

start() 方法调用
1. 启动当前对象的线程
2. 调用对象线程的 run() 方法
不能直接使用 run() 方法启动线程

已经 start() 启用的线程不能再被 start() 方法启用

package October_14;

class MyThread extends Thread {
    @Override
    public void run() {

    }
}

public class uesThread {
    public static void main(String[] args) {

        MyThread myThread1 = new MyThread();
        // 测试在已被启用的线程能否再次被启用
        myThread1.start();
        myThread1.start();
    }
}

结果：

Exception in thread "main" java.lang.IllegalThreadStateException
会报错

方式二：实现 Runnable 接口

创建一个实现了 Runnable 接口的类
实现类中实现 Runnable 接口的抽象方法：run()
创建实现类的对象
将此对象作为参数传递到 Thread 类的构造器中，创建 Thread 类的对象

通过 Thread 类的对象调用 start() 方法

package October_14;

// 1. 创建一个实现了 Runnable 接口的类
class runnableMethod implements Runnable {
    @Override
    // 2. 实现类中实现 Runnable 接口的抽象方法：run()
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        // 3. 创建实现类的对象
        runnableMethod rm = new runnableMethod();

        // 4. 将此对象作为参数传递到 Thread 类的构造器中，创建 Thread 类的对象
        // 如果想要生成相同功能的多线程,只需要创建多个 Thread 对象就可以了
        Thread thread = new Thread(rm);
        Thread thread2 = new Thread(rm);
        // 5. 通过 Thread 类的对象调用 start() 方法
        thread.start();
        thread2.start();
    }
}

提示：
- 可以多个 Thread 类对象共用同一个 Rannable() 的实现类对象。Rannable() 的实现类对象的数据是共用的。

两个方式的不同：
- 开发中：优先选择：实现 Rannable() 接口的方法
  
  原因：
  1. 实现的方式没有单继承的局限性
```
 	2. 实现的方式更适合多个线程共享数据的情况
```

2. Thread 类的使用

方法的使用
- start() ：启动当前对象线程；调用当前线程的 run()
- run() ：通常需要重写 Thread 类中的此方法，将创建线程需要执行的操作声明在此方法中
- currentThead() ：静态方法，返回当前对象线程的信息
- getName() ：获取当前线程的名字
- setName() ：设置当前线程的名字
- yield() ：释放当前CPU的执行权
- join(long millis) ：在线程a中调用线程b的join方法，线程a释放CPU执行权让线程b执行，直到线程b结束后再继续执行。
  
  join() 必须在 start() 调用之后才有意义。
- sleep(long millis) ：让当前线程“睡眠”指定的millis毫秒。当前线程是阻塞状态。
- isAlive() ：判断当前线程是否还存货
线程的优先级
- 线程优先级情况
  - MAX_PRIORITY：10（最高优先级）
  - MIN_PRIORITY：1（最低优先级）
  - NORM_PRIORITY：5（正常优先级）
- 涉及方法
  - getPriority() ：返回线程优先级
  - setPriority(int p) ：设置线程优先级
- 说明
  
  高优先级的线程要抢占低优先级CPU的执行权。仅代表高优先级线程高概率被执行，并不是高优先级线程完成后才到低优先级。