0
点赞
收藏
分享

微信扫一扫

C++的一些基础语法

君之言之 03-13 14:30 阅读 3

目录

🎈认识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()方法。俩者的区别是:

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

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


如果实行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);
        }
    }

举报

相关推荐

0 条评论