Java编程--多线程/多线程的构造/多线程的属性/线程中断/线程的状态/线程等待

       前言 

        逆水行舟，不进则退！！！     

---

       进程与线程

        什么是进程？           

        答：进程是操作系统分配资源的最小单元，它是运行中的程序的实例，或者说，是应用程序的一次动态执行。例如，当你在电脑上打开一个软件，如浏览器，操作系统就会为这个软件创建一个新的进程。在这个进程中，浏览器将获取CPU时间、内存等系统资源来执行它的功能。每个进程都具有独立的内存单元，这意味着每个进程之间相互独立，互不干扰。以一个生活中的例子来解释，进程就好比你去银行转账，你对银行来说就是一个进程。银行为你提供了接待员、转账人员、银行电脑等资源来为你完成转账这一整个服务流程。而银行对其他人的服务并不干扰你。

        什么是进程控制块？       

        答：进程控制块（PCB）是操作系统中的关键数据结构，主要用于描述和控制进程。它包含了标识进程信息的必要数据，如进程标识符、进程状态、程序计数器、寄存器、内存分配情况、打开文件列表以及进程优先级等。每个进程都有一个唯一的进程控制块，它是进程存在的唯一标识，操作系统通过这个控制块找到进程并进行管理和调度。例如，当需要暂停当前进程并切换到另一个进程时，就需要保存当前进程的上下文信息，包括CPU寄存器、程序计数器、堆栈指针等，而这些信息都存储在PCB中。因此，PCB是操作系统对进程进行具体识别和控制的依据，也是进程的集中特性反映。

        什么是线程？             

        答：线程是进程内部的一个执行单元，它负责执行进程中的程序。一个进程中至少有一个线程，当然，一个进程也可以拥有多个线程，这样的程序也被称为多线程程序。线程有着自己的进程控制块（PCB），但是它们并没有独立的地址空间，而是与所属进程共享同一个地址空间。这意味着，每个线程进行数据交换时，都可以直接访问进程内的共享数据，这大大提高了数据访问的效率。

        举个生活中的例子，你正在准备一顿丰盛的晚餐，做菜、切菜、洗菜等各个环节都可以看作是线程，它们共同构成了准备晚餐这个进程。其中，切菜和炒菜这两个线程之间可能需要进行数据交换，由于它们在同一个进程中，因此这种数据交换非常快速且高效。

        进程与线程的区别是什么？

        答：

                1，进程是计算机系统分配资源的基本单位；线程是计算机系统调度和分派的基本单位。

                2，进程是一个动态概念，每个进程都有自己的地址空间和系统资源；线程是进程中的一个执行单元，是进程中的一个实体，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器、寄存器和栈）；

                3，进程间相互独立，互不干扰；线程可与同属一个进程的其他线程共享进程所拥有的全部资源，包括进程的堆 和 方法区 资源。

                4，进程间切换，时空开销大：空间开销主要源于上下文信息的保存与恢复，由于每个进程拥有自己独立的地址空间，因此，在进程切换时，需要保存和恢复大量的上下文信息，包括程序计数器、寄存器以及内存映射等。时间开销也不容忽视。进程间的切换涉及到CPU状态的保存和恢复，这一过程需要耗费一定的时间。例如，在单核系统中，如果需要在进程A和进程B之间进行切换，那么首先需要将CPU的状态保存到进程A的上下文中，然后再加载进程B的上下文到CPU中。

相比之下，线程间切换则相对轻量。因为同一进程内的多个线程共享相同的地址空间，所以线程切换只需保存和恢复少量的上下文信息，如PC指针和寄存器的值。此外，线程的创建也比进程简单得多，只需要确定PC指针和寄存器的值，并给线程分配一个栈用于执行程序。这也是多线程被广泛应用的原因之一，它能够有效提高系统的并发性和性能。

        

        什么是多线程？                

        答：多线程是指在一个程序中同时运行多个线程来完成不同的工作，以提高程序的效率和性能。线程是进程中的一个执行单元，它是进程内的一个执行流程，也是程序执行的最小单位。一个进程中至少有一个线程，当然，一个进程也可以拥有多个线程，这样的程序也被称为多线程程序。多线程技术使得程序可以同时处理多个任务，从而提高了程序的效率和响应速度。在应用程序中，如果要对线程进行调度，最直接的方式就是设置线程的优先级。优先级越高的线程获得CPU执行的机会越大，而优先级越低。

         

---

       线程的创建

        1，继承Thread，重写run() 方法；

class MyThread extends Thread {

    // 重写run() 方法
    @Override
    public void run() {
        while(true) {
            System.out.println("hello world");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        //t.run();

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

        

        2，实现Runnable接口

//Runnable的作用 是表述了一个 “要执行的任务”， run方法就是执行任务的细节
class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("hello thread");
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        //这只是描述了个任务
        Runnable runnable = new MyRunnable();
        //然后 把任务交给线程来执行
        Thread t = new Thread(runnable);
        t.start();

        这种写法是 解耦合，目的就是为了让线程 和 线程要干的活 之间分离开。
        未来如果要该代码，不用多线程了，使用多进程，或者此线程池，或者协程....此时代码改动比较小。
        */
    }

}

       

        3，使用匿名内部类，继承Thread

public class ThreadDemo3 {
    public static void main(String[] args) {
// 创建了一个Thread 的子类，（子类没有名字），创建了子类的实力，并且让 t 引用指向该实例
        Thread t = new Thread() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        };
        t.start();
    }
}

        4，使用匿名内部类，实现Runnable；

public class ThreadDemo4 {
    public static void main(String[] args) {
// 这个写法 和 使用匿名内部类 继承 Thread 本质相同，
//只不过是把实现Runnable 的任务交给了匿名内部类的语法

// 此处是创建了一个类，实现Runnable， 同时创建了类的实例，并且传给了Thread的构造方法。
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hell0");
            }
        });
        t.start();
    }
}

        5，使用lambda表达式实现

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello");
        });
        t.start();
    }
}

---

       线程的属性

属性	获取方法
ID	getId()
名称	getName()
状态	getState()
是否后台线程	isDaemon()
是否存活	isAlive()
是否被中断	isInterrupted()

getId() 方法：getId() 方法返回的是该线程的唯一标识符，

getName() 方法：该方法可以返回当前线程的名称。并不是指向该线程的引用的名称。

IsDaemon() 方法：返回当前线程是否为后台线程。isDaemon 守护线程就是后台线程，切换到后台运行的线程就是后台线程

 

---

       线程中断      

        中断一个线程，中断的意思是： 不是让线程立即就停止，而是通知线程，你应该要停止了，是否真的停止，取决于线程这里具体的代码写法。

       

1，使用一个标志位，来控制线程是否终止。

2，使用 Thread 自带的标志位，来进行判定，

        为什么sleep要清除标志位？

                答：唤醒之后，线程到底要终止还是不要终止，到底是立即终止还是稍后终止，就把选择权交给程序员了。

---

       线程的状态      

1，NEW  创建了Thread对象，但是还没有调用start（内核里还没有创建对应的PCB);

2，TERMINATED   表示内核中的PCB已经执行完毕了（PCB 释放了），但是Thread对象还在。

3，RUNNABLE  可运行的线程，包括以下两种：

        a）正在CPU上执行的线程。

        b）在就绪队列中，可以随时去CPU上执行

4，WAITING

5,  TIMED_WAITING

6,  BLOCKED

        4、5、6都是阻塞，表示线程PCB正在阻塞队列中。只是阻塞的原因不同。

---

       线程等待

        有时，我们需要等待一个线程完成它的工作后，才能进行自己下一步工作。这就是线程等待存在的意义。

方法	说明
public void join()	等待线程结束
public void join(long millis)	等待线程结束，最多等 millis 毫秒
public void join(long millis, int nanos)	同理，但可以更高精度

        join()无参时， 就是死等。有参数的 join 方法 是制定一个最大等待时间。

      

        注：如果主线程调用t.join() 的时候，t 线程已经结束了，join不会阻塞，会立即返回。

---

        我是专注学习的章鱼哥~