【Java_EE】线程创建

建议：一定要看代码中的内容，其中写了一些注解，那才是精华！！！

线程创建的方法：

方法一：创建Thread线程子类，重写run()方法。

class MyThread extends Thread{
    /**
     * 重载：在同一个作用域中，多个方法之间名字相同，参数列表不相同。
     *
     * 重写：父类子类之间，子类重写父类方法，子类中重写的方法有时会代替父类的方法执行，实现了动态绑定。
     *
     * @Override 重写注解，提示编译器进行更严格的检查。
     *
     * 抢占执行：多个线程的调度顺序是 “无序” 的。
     *
     *
     *
     * 方法：
     * // run()： 描述线程具体执行什么任务，只是描述
     *       执行：1、run()方法并不是start()方法调用的
     *            2、run()方法是start()方法创建出来的线程，在自己线程里被调用的
     *       定义：1：run()方法只是定义好，而不手动调用，此方法的调用交给其他系统/库/框架调用
     *            2：此类方法称为 “回调函数” （callback function) -》自己不调用，给别人调用
     *            联想：函数指针-》指向函数的指针（C语言）
     *                 1：使用函数指针实现转移表的效果，降低代码的圈复杂度
     *                 2：使用函数指针达成“回调函数”效果（qsort指定比较规则）
     *                 比较器（Java数据结构）
     *                 1：PriorityQueue优先级队列，针对自定义的类，需要指定比较器才能明确大小规则
     * // sleep()：让线程主动进入“阻塞状态”（a线程出差，无法随叫随到），主动放弃在CPU上运行，时间到后重新调度到CPU上执行
     *       好处：让CPU消耗资源大幅度降低了。
     *       问题：服务器程序消耗CPU资源超出预期。
     *             如何排查此问题？
     *            1、先确定那个线程消耗CPU比较高（使用第三方工具进行查看）
     *            2、确定线程后，查看该线程中是否有 “快速循环”
     *             如何解决此问题？
     *            1、确定清楚，此处的循环是否本应该如此快？
     *            2、是：升级更好的CPU
     *              否：在循环中引入一些 “等待操作” （不一定是sleep)
     * // start()：1、调用操作系统提供的 “创建线程”api
     *             2、在内核中创建对应的pcb，并把pcb加入到链表中
     *             3、系统调度到此线程，则会执行run()方法中的逻辑
     */

    @Override
    public void run() {
        System.out.println("hello thread!");
        while (true) {
            System.out.println("thread线程");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

/**
 *  创建线程写法一：
 *  1、创建Thread线程子类，重写run()方法
 */
public class test_1 {
    // 启动程序在main方法中启动！！！

    /**
     * // 一个进程中至少有一个线程
     * 主线程（main) - jvm自己提供的
     * thread线程 // 俩线程在并发执行（各线程里面具体是并行还是并发并不知道）
     *
     * // jdk -> bin -> jconsole.exe（.exe可执行文件）
     * 用于监视一个进程中各线程的状态
     *
     * // 抢占执行
     * 抢占执行：多个线程的调度顺序是 “无序” 的。（操作系统内部称为“抢占执行）
     * 小众执行方式：实时操作式执行（发射卫星）、协商是执行
     */
    public static void main(String[] args) {
        // 向上转型
        Thread thread = new MyThread();

        //thread.start();
        // 执行方式：抢占式执行（并发执行）
        // 启动此线程，并且创建了run()方法所在线程，该线程则会调用run()方法

        thread.run();
        // 如果没有使用start()方法，直接使用线程调用run()方法。
        // 执行方式：串行执行
        // 串行执行：run()方法中的循环结束，才能继续执行到下一个循环

        while (true) {
            System.out.println("主线程（main）");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

start（）方法存在时执行的是抢占式执行；
直接调用run（）方法时是串行执行，结束当前循环才能执行下一循环。

---

方法二：通过runnable接口创建线程

class MyRunnable implements Runnable{
    /**
     * Runnable接口：只是描述一个“任务”，这个任务和具体的执行机制无关。（通过线程的方式执行，还是通过其他方式执行都无关）
     *         好处：1、runnable描述任务，此处线程执行该任务
     *              2、目的引入解耦合，任务内容和线程拆分开，可以使用其他方式执行任务（线程池，虚拟线程）
     */
    @Override
    public void run() {
        while (true) {
            System.out.println("use runnable");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
/**
 *  创建线程写法二：
 *  1：通过runnable接口创建线程
 */
public class test_2 {
    public static void main(String[] args) {
        // 直接创建线程对象
        // 在线程对象中传一个我们自己写的runnable实例
        Thread thread = new Thread(new MyRunnable());
        thread.start();// 调用的Thread中的start

        while (true) {
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

*

直接创建线程对象

在线程对象中传一个我们自己写的runnable实例

Thread thread = new Thread(new MyRunnable());

---

方法三：使用匿名内部类创建线程

/**
 * 创建线程写法三：
 * 1：本质就是方法1和方法2，但是换一个写法
 * 2：使用匿名内部类来实现
 *   匿名：这个类没有名字
 *   内部类：该类定义在别的类里面
 */
public class test_3 {
    public static void main(String[] args) {
        /**
         * 1：new的不是Thread,而是创建了一个Thread的子类。（只是不知道名字，是匿名的）
         * 2：同时在该内部类中创建了一个子类实例。（匿名内部类只能创建一个实例，实例创建完后就拿不到这个类了）
         * 3：在子类中重写run()方法
         */
        Thread thread = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("匿名内部类");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        thread.start();

        while (true) {
            System.out.println("main线程");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

匿名内部类只能创建一个实例，实例创建完后就拿不到这个类了。

---

方法四：匿名内部类创建线程，将Runnable实例作为参数传入到方法中

/**
 * 基本定义：
 *        进程：运行起来的程序
 *        线程：轻量级进程
 *        进程地系统资源分配的基本单位
 *        线程是系统调度执行的基本单位
 *        一个进程至少包含一个线程，也可以包含多个线程
 * Thread类，创建线程：
 *                  1：继承Thread类，重写run()方法
 *                  2：实现Runnable，重写run()方法，将Runnable实例传入到Thread中 (解耦合）
 *                  3：使用匿名内部类，继承Thread，重写run()方法
 *                  4：匿名内部类，针对Runnable
 *                  5：使用lambda表达式，针对匿名内部类的平替（推荐写法）
 *
 *
 */


/**
 *  创建线程写法四：
 *  1：使用匿名内部类，针对Runnable（只针对Runnable，和Thread没关系）
 *  2：只是将Runnable的实例，作为Thread的参数传入到Thread的构造方法中
 *
 */
public class test_4 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("匿名内部类，针对Runnable");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });

        thread.start();

        while (true) {
            System.out.println("主线程（main）");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

---

方法五：lambda创建线程（最常用的方式）

/**
 * 方法五：使用lambda表达式
 *      （lambda本质就是针对匿名内部类的平替——匿名函数：一次性函数，用完就丢。）
 *
 * Thread thread = new Thread();
 * // 在参数中去写一个lambda
 * // 在参数位置写一个括号，再放一个箭头，最后加上大括号（）->{}。
 * // 此处的lambda就是代替run方法
 *
 */

public class test_5 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            // 此处的lambda就是代替run方法
            while (true) {
                System.out.println("lambda");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        thread.start();

        while (true) {
            System.out.println("main线程");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

---

 异常回顾：

1、try、catch、throw、throws

/**
 *  回顾异常：
 *  try {
 *      尝试运行的代码
 *  }catch(将try中的错误对象传递作为catch中的参数) {
 *      // 当try中代码有异常时，才会执行catch中的代码
 *  }
 *
 * catch中应该写些什么？
 * 1、可能会打印一些日志，把出现的异常的详情都记录到日志文件中；
 * 2、触发一些重试类的操作；
 * 3、触发一些“回滚”类的操作；
 * 4、触发一些报警机制（给程序员发短信/打电话 目的：告诉程序员程序出问题了）
 *
 *
 *  抛出异常的三种形式：
 *  1、throw
 *  2、throws
 *  3、系统自动抛异常
 *
 *  throw和throws的区别：都是处理异常的关键字（相同）
 *  1、位置不同：
 *           throw：在函数内，后面跟的是异常对象；
 *           throws：在函数上，后面跟的是异常类，可以跟多个；
 *  2、功能不同：
 *           throw：抛出具体的问题对象，执行throw将问题对象抛给调用者。
 *           throws：用来声明异常，只将异常信息进行声明但不进行处理。让调用者只知道该功能可能会出现的问题，可以给出预先的处理方式，
 *  3、throw表示出现异常的一种可能性，并不一定发生这些异常；throws抛出异常，执行throw一定抛出了某个异常对象。
 */
public class exception {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

        try{
            // 除数不能为0
            System.out.println(a/b);
        }catch (Exception e){
            // 只有当try中代码发生异常才会执行
            throw new ArithmeticException("除数不能为0");
        }
        finally {
            // 无论有无异常都会执行（finally可写可不写）
            System.out.println("此处除数为0");
        }
    }
}

2、方法签名（重载、重写）

---

面试题：

1、在Java中有哪些方法可以创建线程？

2、throw和throws的区别？