【初识多线程1】

陈陈陈一行

已于 2023-04-10 23:41:25 修改

阅读量58

点赞数

分类专栏：多线程文章标签： java-ee

于 2023-04-10 23:38:05 首次发布

本文链接：https://blog.csdn.net/2201_75880526/article/details/130059445

版权

多线程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

进程是操作系统对运行程序的抽象，线程则是在进程内执行的“执行流”。线程相比进程更轻量，创建和销毁更快，是调度的基本单位。Java中创建线程可以通过继承Thread类或实现Runnable接口，包括匿名内部类和lambda表达式的方式。文章探讨了进程线程的区别以及多线程编程的基础知识。

摘要由CSDN通过智能技术生成

1.进程

1.1 什么是进程（Process）

进程是操作系统对一个正在运行的程序的一种抽象，换言之，可以把进程看做程序的一次运行过程。

比如：正在运行的微信、QQ、游戏等。

这就是电脑上面的一些进程。

2. 线程

2.1 为什么要引入线程

首先操作系统引入进程，目的就是为了能够实现多个任务并发执行。但是进程有个重大的问题，就是比较重量，如果频繁的创建和销毁进程，成本就会大大提高；主要是体现在资源分配上。为了解决这个问题，操作系统引入线程这个概念，假设把进程比喻成一个工厂，线程就是工厂中的一条流水线。如果工厂想要提高产量，一般有两种方法，第一种是新建一个工厂，从而去扩大生产规模，这样耗费的成本就大大提升了；第二种方法就是在原有的工厂里面，新增一条流水线，也就是在一个进程当中再创建一个线程，这样的话可以节省很多成本。

方法一

方法二

很明显，在一个进程中创建新的线程可以节省很多成本。

2.2 什么是线程

一个线程就是一个“执行流”，每个线程之间都可以按照顺序执行自己的代码。多个线程之间“同时”执行着多份代码。

2.3 线程的优点

虽然多进程也能实现并发编程，但是线程比进程更加轻量。

创建线程比创建进程更快速。
销毁线程比销毁进程更快速。
调度线程比调度进程更快速。

所以说，在操作系统中，真正调度的，是在调度线程，而不是进程。

线程是操作系统调度运行的基本单位。

进程是操作系统资源分配的基本单位。

一个进程中的多个线程之间，共用同一份系统资源：（1）内存空间（2）文件描述符。

只有在线程启动，创建第一个线程的时候，需要花成本去申请系统资源。一旦进程（第一个线程）创建完毕，后续再创建的线程，就可以不用在申请资源，创建和销毁的效率就提高了不少。

2.4 进程和线程的区别

进程包含线程。
进程有自己独立的内存空间和文件描述符，同一个进程中的多个线程之间，共享同一份地址空间和文件描述符表。
进程是操作系统资源分配的基本单位；线程是操作系统调度执行的基本单位。
进程之间具有独立性，一个进程挂了，不会影响到别的进程。但是同一个进程里的多个线程之间，一个线程挂了，可能会把整个进程带走，影响到其他线程。

3.创建线程

Java当中，要去创建一个线程需要使用标准库中提供的一个类Thread类。Thread能够表示一个线程。

方法一继承Thread类

首先创建一个Thread的子类，然后继承Thread，同时重写里面的run方法

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello t");
    }
}

接着在main方法中，创建一个MyThread的实例，t的引用实际上是指向子类的实例；通过t.start去启动线程，这样就是在当前进程中创建了另外一条流水线（新的线程），新的线程开始并发执行另外一个逻辑，也就是run方法里面的代码。

t.start();//千万不能漏写

class MyThread extends Thread{
    @Override
    public void run() {
        while (true) {
            System.out.println("hello t");
            try {
                Thread.sleep(1000); //使用sleep,方便观察代码变化
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.start();

        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

上述代码中涉及到两个线程，一个是main方法所对应的线程（一个进程里至少得有一个线程）也可以称为主线程；一个是通过t.start创建的新线程。

调整代码，运行时会发现idea在交替打印，线程是同时运行的，只不过打印出来的结果是有先后，因为两个线程在同一个控制台上面打印，控制台会顺序输出。

此处的交替也不是严格意义的交替，每一秒过后，实现打印main还是先打印T。是不确定的。

因为多个线程在CPU上调度执行的顺序的不确定的（随机）。

方法二实现Runnable 接口

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while (true) {
            System.out.println("hello t");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();

        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

方法三匿名内部类创建Thread子类对象

  public static void main(String[] args) {
        Thread t = new Thread(){ "在此处重写run方法"};
    }

 public static void main(String[] args)  {
        Thread t = new Thread(){
            @Override
            public void run() {
                while (true){
                    System.out.println("hello t");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();

方法四匿名内部类创建Runnable子类对象

 public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("hello t");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t.start();

方法五 lambda表达式创建Runnable子类对象（经常使用）

  Thread t1 = new Thread( () -> System.out.println("使用匿名类创建Thread子类对象"));

Thread t2 = new Thread( () -> {
            System.out.println("使用匿名类创建Thread子类对象");
        });

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