【JavaEE初阶】多线程(1)

最新推荐文章于 2024-10-12 21:06:55 发布

逸狼

最新推荐文章于 2024-10-12 21:06:55 发布

阅读量1k

点赞数 53

文章标签：服务器运维

本文链接：https://blog.csdn.net/2301_80898480/article/details/141869065

版权

欢迎关注个人主页：逸狼

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

如有错误，欢迎指出~

目录

并发编程

线程与进程

创建线程

写法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{

    @Override
    public 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() {
            @Override
            public 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() {
            @Override
            public 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);
        }
    }
}