【JavaEE初阶系列】——多线程之创建线程

news2024/11/20 10:01:19

🎈认识Thread类

🎈Sleep

🎈创建线程

🚩继承Thread，重写run方法

🚩实现Runnable接口，重写run方法

🚩使用匿名内部类创建 Thread 子类对象

🚩使用匿名内部类，实现Runnable接口

🚩Lambda表达式

我们之前接触到的程序都是单线程的，不是多线程的，就是程序运行的时候，进行的是多个方向(线程）打印。其实就是单线程只进行一个任务，多线程是同时进行俩个任务。

感受多线程程序和普通程序的区别

每个线程都是一个独立的执行流
多个线程之间是 "并发" 执行的.

🎈认识Thread类

我们首先来认识认识这个类，这个类是java.lang包下的，所以我们就可以直接使用进行。

class Mythread extends Thread{
    @Override
    public void run() {
        //这个方法就是线程的入口
        System.out.println("创建一个类并且继承Thread类");
    }
}

我们创建一个类继承父类Thread线程，重写run方法。这个方法就是线程的入口。

Thread里面的成员有俩个，一个是run(),一个是start()方法。俩者的区别是：

start（）则是真正调用了系统API，在系统中创建出线程，让线程再调用run.(兵分俩路，并发执行）

我们把上述的代码弄成死循环，然后我们可以看到，俩个while循环再“同时执行”，看到的结果是俩边的日志都在交替打印。

这就是并发编程的效果，充分的使用了多核cpu资源。

run() 只是描述了进程的入口（进程要做什么任务）

如果实行run()方法的话，那么此时的代码不会创建新的线程，只有一个主线程，这个主线程里面只能依次循环，执行完一个循环再执行另一个。（因为上面start调用了系统的api，让系统再调用run()方法，所以我们就实现了后面的代码）但是这个run()不能创建新的线程，只能去创建一个主线程，再自己创建的类里面的run()方法。

因为这一题我都是死循环，所以不管只能执行上面调用run()方法的线程，而下面的线程是不能执行的。main线程其实也是一个线程，但是一个java中至少会有一个main线程。

🎈Sleep

因为用while(true)循环之后，我们发现执行的太快了，我们需要他慢点执行，让我们更加清楚的看到执行的情况。Thread里面重写了sleep方法。是静态方法，是依赖于类的，而不是依赖于对象的

这样的设计也合乎情理，我们是依赖于Thread类进行实现睡眠状态。

我们看到每秒打印的内容是不一样的。操作系统，对于多个线程的调度顺序，是不确定的，随机的，取决于操作系统对于线程调度的模块（调度器），不过关于谁先打印，大概率是main方法下的，因为调用start之后，新的线程被创建也是有一定的开销的，创建过程中，主线程就执行了自己main方法下的线程。（当然无法排除极端情况，主线程正好卡了下，使新线程的日志先打印....）

🎈创建线程

🚩继承Thread，重写run方法

通过自定义一个类（这里起名为：MyThread），继承Thread类，重写run方法，最后在main方法中new出MyThread实例，调用这个实例的继承的Thread类的start方法创建一个线程。

1.创建出MyThread实例，并不代表在系统真的创建一个线程，只有调用start方法时，才创建出一个新的线程，新线程会执行run里的逻辑，直到run里逻辑执行完，线程就结束了；
2.运行一次Java程序就启动了一个进程，一个进程里至少会有一个线程，这里JVM默认创建的线程就是main线程（主线程），main主线程和MyThread创建出来的新线程是“并发执行”的关系（并发+并行），也可以理解为同时执行，各执行各的；
3.直接调用run并没有创建线程，只是在原来的线程中执行代码；

class MyThread extends Thread{
    @Override
    public void run() {
        while (true){
            System.out.println("Thread begin");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public static void main(String[] args) throws InterruptedException {
        //继承Thread 重写run方法
        Thread thread=new MyThread();
        thread.start();
        while(true){
            System.out.println("main begin");
            Thread.sleep(1000);
        }
    }

🚩实现Runnable接口，重写run方法

通过自定义一个类（这里起名为：MyRunnable）实现Runnable接口，重写run方法，最后在main方法new出MyRunnable实例和Thread实例，最后通过start方法创建并启动线程。

这里相当于把线程要干的活和线程本身分离开了，使用MyRunnable这个自定义的类来表示“线程要完成的任务”，这样做的目的就是为了“解耦合”，假设未来有新的任务需要线程去执行，那么通过这种方式，代码改动就比较小。

class MyRunable implements Runnable{
    //实现Runnable接口 重写run方法
    @Override
    public void run() {
        while (true){
            System.out.println("Runnable begin");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}


 public static void main2(String[] args) throws InterruptedException {
        //实现Runnable接口 重写run方法
        Runnable runnable=new MyRunable();
        Thread thread=new Thread(runnable);
        thread.start();
        while (true){
            System.out.println("main begin");
            Thread.sleep(1000);
        }

    }

🚩使用匿名内部类创建 Thread 子类对象

直接创建Thread子类，同时实例化出一个对象，重写run方法，最后通过start方法创建并启动线程.

 Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类创建 Thread 子类对象");
            }
        };
        thread.start();
    }

🚩使用匿名内部类，实现Runnable接口

通过使用使用匿名内部类，实现Runnable接口作为Thread构造方法的参数，最后通过start创建并启动线程；

  public static void main4(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类，实例Runnable接口作为构造参数;");
            }
        });
    }

🚩Lambda表达式 (推荐方法）

lambda本质上就是一个“匿名函数”，()表示函数的形参，{}表示函数体，->特殊语法，表示它是lambda表达式(->是从C++那里抄来的)。

 public static void main3(String[] args) throws InterruptedException {
        //使用Lambda 创建Thread子类对象
        Thread thread=new Thread(()->{
            while ((true)){
                System.out.println("run");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread.start();
        while (true){
            System.out.println("进行");
            Thread.sleep(1000);
        }
    }