目录
🎈认识Thread类
🎈Sleep
🎈创建线程
🚩继承Thread,重写run方法
🚩实现Runnable接口,重写run方法
🚩使用匿名内部类创建 Thread 子类对象
🚩使用匿名内部类,实现Runnable接口
🚩Lambda表达式
我们之前接触到的程序都是单线程的,不是多线程的,就是程序运行的时候,进行的是多个方向(线程)打印。其实就是单线程只进行一个任务,多线程是同时进行俩个任务。
- 每个线程都是一个独立的执行流
- 多个线程之间是 "并发" 执行的.
🎈认识Thread类
我们首先来认识认识这个类,这个类是java.lang包下的,所以我们就可以直接使用进行。
class Mythread extends Thread{@Overridepublic 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{@Overridepublic 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方法@Overridepublic 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() {@Overridepublic void run() {System.out.println("使用匿名内部类创建 Thread 子类对象");}};thread.start();}
🚩使用匿名内部类,实现Runnable接口
通过使用使用匿名内部类,实现Runnable接口作为Thread构造方法的参数,最后通过start创建并启动线程;
public static void main4(String[] args) {Thread thread=new Thread(new Runnable() {@Overridepublic 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);}}
坚持下去。