「这是我参与11月更文挑战的第2天，活动详情查看：2021最后一次更文挑战」

1.线程的生命周期：

说明：

线程的生命周期关注两个概念：状态、相应的方法
状态
- 状态a —> 状态b：哪些方法执行了（回调方法），某个方法主动调用：状态a —> 状态b
- 阻塞：
  - 临时状态，不可作为最终状态
- 销毁状态：最终状态 相应的方法：
设置线程名

     MyThread myThread = new MyThread();     //创建继承的Thread类的线程实例
     myThread.setName("线程一");

设置线程的优先级

 myThread.setPriority(10);

获取当前线程的优先级

 Thread.currentThread().getPriority()

获取当前线程的线程名

 Thread.currentThread().getName()

2.多线程的创建方式

方式一：继承于Thread类

实现步骤
1. 创建一个继承于Thread类的子类
2. 重写Thread的run（）方法
3. 创建Thread类的子类的对象
4. 通过此对象调用start（） 示例：输出100以内的偶数

class MyThread extends Thread{
    //重写Thread的run方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i%2==0){
                //Thread.currentThread().getName()：获取当前线程名
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    } 
}
public class ThreadTest_01 {
    public static void main(String[] args) {

        //启动线程
        MyThread myThread = new MyThread();
        myThread.start();
}

方式二：实现Runnable()接口

实现步骤
1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable中的抽象方法：run()
3. main方法中创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start() 示例：输出1-10的整数

//1、创建一个继承Runnable接口的类
class ThreadRunnableTest implements Runnable{

    //2、实现Runnable中的run()方法
    @Override
    public void run() {
        for (int i=1;i<=10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

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

        //3、创建ThreadRunnableTest类的对象
        ThreadRunnableTest threadRunnableTest = new ThreadRunnableTest();

        //4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(threadRunnableTest);

        //5、通过Thread类的对象调用start()方法:①启动线程，②调用当前线程run()-->调用了Runnable类型的target的run()
        thread.start();
    }
}

方式三：实现Callable接口

实现Callable接口的方式创建多线程相比较实现Runnable接口创建线程方式强大之处？
- call()可以有返回值的。
- call()可以抛出异常，被外面的操作捕获，获取异常信息。
- Callable支持泛型。
实现步骤
1. 创建一个实现Callable接口的实现类
2. 实现其中的call()方法，将线程需要执行的操作声明在call()方法中
3. 创建Callable()接口实现类的对象
4. 将此对象作为参数传递到FutureTask构造器中，创建出FutureTask的对象
5. 将创建的FutureTask对象作为参数传递到Thread类的构造器中，创建出Thread对象，并调用start()方法启动线程 示例：计算100以内所有偶数的和

//1、创建一个实现Callable的实现类
class NumThread implements Callable{
    //2、实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i%2==0){
                sum+=i;
            }
        }
        return sum;
    }
}

public class ThreadNew {

    public static void main(String[] args) {
        //3、创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4、将此Callable接口实现类的作为对象传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6、获取Callable中call方法的返回值

            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println("最终结果是："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

方式四：使用线程池

实现步骤
1. 提供指定线程数量的线程池
2. 设置线程池的属性
3. 执行指定的线程的操作，需要提供实现Runnable接口或者Callable接口的实现类对象
4. 关闭线程池示例：输出1-10的整数

/**
 *  优点：
 *  1.提高响应速度(减少了创建新线程的时间)
 *  2.降低资源消耗（重复利用线程池中线程，不需要每次都创建)
 *  3.便于线程管理
 *      corePooLsize:核心池的大小
 *      maximumPoolsize:最大线程数
 *      keepAliveTime:线程没有任务时最多保持多长时间后会终止
 */
public class ThreadPool {
    public static void main(String[] args) {
        //1、提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //ExecutorService是一个接口，不能为其设置属性，而它的实现类有ThreadPoolExecutor，可以转换为该类的类型进行属性的设置
        ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
        
        //设置线程池的属性
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //2、执行指定的线程的操作，需要提供实现Runnable接口或者Callable接口的实现类对象
        service1.execute(new ThreadRunnableTest());
        //适合适用于实现Callable接口的方式
//        service.submit();

        //3、关闭线程池
        service1.shutdown();
    }
}

开发中：优先选择实现Runnable接口的方式

原因：
- 实现的方式没有类的继承的局限性
- 实现的方式更适合来处理多个线程有共享数据的情况。
联系：public class Thread implement Runnable
相同点：两种方式都需要重写run（），将线程要执行的逻辑声明在run（）中。

Java多线程的使用~

1.线程的生命周期：

2.多线程的创建方式

方式一：继承于Thread类

方式二：实现Runnable()接口

方式三：实现Callable接口

方式四：使用线程池