【JavaEE初阶】多线程(1)

欢迎关注个人主页：逸狼

创造不易，可以点点赞吗~

如有错误，欢迎指出~

目录

并发编程

线程与进程

创建线程

写法1

写法2

写法3

写法4

写法5

Thread类的常见构造方法

前台/后台线程

并发编程

并发编程: 通过写特殊的代码把多个cpu的核心都利用起来

多进程编程就是一种典型的并发编程 ,但多进程编程最大的问题是进程太'重'了(创建进程/销毁进程,时间/空间开销比较大,一旦需求场景需要频繁的创建销毁进程 ,开销就非常明显了(最典型的就是服务器开发(针对每个发送请求的客户端,都需要创建一个单独的进程,由这个进程负责给客户端提供服务)))

线程与进程

为解决进程开销比较大的问题,发明了'线程'(可以理解为更轻量化的进程,也能解决并发编程的问题,创建/销毁的开销要比进程更低,因此多线程的编程就成为了当下最主流的并发编程方式(通过多线程可以充分利用好多核cpu))

进程在系统中是通过PCB这样的数据结构来描述的,通过链表的形式来组织的, 线程同样也是通过PCB来描述的(一个进程,是一组PCB,一个线程,是一个PCB,存在包含关系:一个进程中,可以包含多个线程)

进程是系统 "资源分配" 的基本单位
线程是系统 "调度执行" 的基本单位

一个可执行程序,运行的时候,操作系统就会创建进程,给这个程序分配各种系统资源(cpu,内存,硬盘,网络带宽....),同时也会在这个进程中创建一个或多个线程,这些线程再去cpu上执行.

一个进程要么包含一个,要么包含多个线程,不能没有
同一个进程中的这些线程 ,共用同一份系统资源

线程比进程 更轻量化 主要在于 创建线程省去了"分配资源" 的过程,销毁线程也省去了'释放资源'的过程 (一旦创建进程,同时也会创建第一个线程--->负责分配资源 ,创建后面的线程就不必分配资源了)

随着线程数目的增加,每个线程要负责完成的工作量就变少了,这些线程同时开始工作,总的消耗时间会进一步减少, 但是如果线程的数目太多,超出了 cpu核心数目,此时就无法再完成所有线程的"并发"执行.势必会存在严重的 '竞争'

多个线程之间 ,可能会相互影响,线程安全问题,一个线程一旦抛出异常,也可能会把其他线程也一起带走.
多个进程之间, 一般不会相互影响,一个进程崩溃了,不会影响其他进程(进程的隔离性)

创建线程

class MyThread extends Thread{//Thread类可以直接使用,不用导入任何包//重写run方法public void run(){System.out.println("hello thread");}
}public class Demo1 {public static void main(String[] args) {MyThread t =new MyThread();//创建线程t.start();//调用start就会再进程内部创建一个新的线程,新的线程就会执行刚才run里的代码}
}

注意:上述代码中,run方法并没有手动去调用, 但这个方法最终执行了,此时这样的方法称为'回调函数'

这个代码运行起来是一个进程,但这个进程中包含两个进程,主线程和新线程 ,这两个线程并发/ 并行的在cpu上执行

写法1

继承Tread ,重写run,通过start 实例启动线程

class MyThread extends Thread{//Thread类可以直接使用,不用导入任何包//重写run方法public void run(){while(true){System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Demo1 {public static void main(String[] args)  {MyThread t =new MyThread();//创建线程t.start();//调用start就会再进程内部创建一个新的线程,新的线程就会执行刚才run里的代码while(true){System.out.println("hello main");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

写法2

实现Runnable ,重写run,通过Thread的实例,把Runnable的实例传进去,再调用start

class MyRunnable implements Runnable{@Overridepublic void run() {//描述线程要完成的逻辑是啥while(true){System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}
public class Demo2 {public static void main(String[] args) throws InterruptedException {MyRunnable runnable= new MyRunnable();Thread t =new Thread(runnable);t.start();while(true){System.out.println("hello main");Thread.sleep(1000);}}
}

Runnable 是用来描述要执行的任务是什么,通过 Thread创建线程,线程要执行的任务是通过Runnable来描述的,而不是通过Thread自己来描述的, 这里的runnable只是一个任务,并不是和'线程'这样的概念强相关,后续执行这个任务的载体,可以是线程,也可以是其他....(有利于代码的解耦合)

写法3

继承Thread,重写run ,通过 匿名内部类来实现,本质上是写法1

package thread;public class Demo3 {public static void main(String[] args) throws InterruptedException {Thread t = new Thread() {@Overridepublic void run() {while (true) {System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}};t.start();while (true) {System.out.println("hello main");Thread.sleep(1000);}}
}

写法4

通过匿名内部类实现本质上是写法2

public class Demo4 {public static void main(String[] args) throws InterruptedException {Thread t= new Thread(new Runnable() {@Overridepublic void run() {while(true){System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}});t.start();while(true){System.out.println("hello main");Thread.sleep(1000);}}
}

写法5

基于 lambda 表达式来创建线程(很多时候,写"匿名内部类"的目的不是为了写"类"而是为了写类里面的方法,lambda就是直接能够表示要写的run方法)

public class Demo5 {public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{while(true){System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});t.start();while(true){System.out.println("hello main");Thread.sleep(1000);}}
}