【javaEE-有关CPU进程和线程实现的并发编程及二者的区别】

本文主要是介绍【javaEE-有关CPU进程和线程实现的并发编程及二者的区别】，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

🔥🔥🔥有关进程并发编程开发的成本问题

这次之前其实我们所有的写的程序都是使用单核心来运行的，但是一般我们的计算机都有很多核心，如果我们编程的时候，只使用一个核心的话，其实这是一个非常大的浪费，所以我们引进了多进程这种并发编程来充分利用计算机的多核心。但是随着我们的需求越来越大，进程的一些缺点就显现出来了。

创建和销毁进程的成本很大
越来越多的需求场景需要一种更方便的并发编程形式
线程的出现

由此我们发明了一个新的并发编程的形式，线程（Thread），对比进程，它的创建和销毁成本更小，更轻量。因此现在的主流并发编程的形式就是多线程编程。

在这里插入图片描述

🔥🔥🔥多线程编程

对于进程来说，一个进程是由一组PCB类似于结构体的形式对数据进行描述，进一步的通过链表的形式将数据组织起来。对于线程来说，一个线程是只有有一个PCB结构的形式，所以这里就有一个包含关系：一个进程中可以包含多个线程,此时每一个线程都可以独立的在CPU上调度执行，这里我们对进程和线程做一个总结：

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

一个可执行的程序，双击exe文件，系统就会创建一个进程，给这个进程中分配一些系统资源（硬盘，cpu，内存，网络带宽等）。在这个进程中会创建一个或多个线程。这些线程才在cpu中调度执行。同一个进程中的多个线程其实是共用同一份系统资源的。

对比进程，线程是更轻量的，主要是在我们创建一个进程的时候，就已经创建了一个线程了，同时就会分配系统资源，后序我们在创建第二个第三个线程的时候，就不用再分配资源了~，因此他就省去了分配资源的过程。也省去了释放资源的过程。在这里插入图片描述

🔥🔥🔥系统分析多线程调度执行过程

比如说现在有请我们最可爱的joey老铁上场，此时在一个房间里他要一个人吃完100只鸡。
在这里插入图片描述
为了提高老铁的吃鸡效率，我们可以引用多进程的概念，在创建一个房间，还是一个joey老铁，只需要吃50只鸡。

这样确实提高了joey吃鸡的效率，但是我们其实不难发现这种效率是非常低的，我们显然可以用一个更简单的方式提高吃鸡的效率，我们可以在一个房间里引进多个joey老铁，这样的方式不仅大大提高了吃鸡的效率，而且大大缩减了成本的损耗。这其实就是多线程的概念。相比于多进程，这种形式效率是极高的。
在这里插入图片描述

那我们就自然的想到，在引进一些线程，会不会进一步提高效率呢？当然会！！！
在这里插入图片描述
但是当我们将线程增加带一些程度的时候，就会出现问题了~

此时就再也无法通过增加线程的方式，提高程序执行的效率了，因为桌子的空间是有限的，我们增加多个joey后，势必会有一些joey老铁是吃不到桌子上的鸡的，即线程多了，cpu的资源是有限的，这样就无法提高效率了。

有时甚至可能会由于线程的增多，导致线程可能会争夺系统资源，最后导致系统崩溃！！！

🔥🔥🔥线程和进程的概念即区别

1. 进程包含线程：即一个进程中可以包含一个或者多个线程，但是不能没有线程，当我们创建一个main函数时就是一个主线程。
2. 进程是系统资源分配的基本单位，线程是系统调度执行的基本单位。
3. 同一个进程中的所有线程其实是共用同一份系统资源的（硬盘，内存，网络带宽等）
4. 线程是当下实现并发编程的主流方式，通过多线程可以很好的利用cpu的多核心特性~但是并不是线程越多越好的，随着线程的增多(当然创建线程也会有一定的开销)，可能会导致多个线程之间争夺系统资源，甚至导致系统的崩溃
5. 多个线程之间，其实也存在一定的安全问题，当一个线程产生异常时，可能也会影响其他线程的正常执行~
6. 多个进程之间一般是不会相互影响的，、一个进程崩溃，并不会影响其他进程的运行(这也称为“进程的隔离性”)。 在这里插入图片描述

这个问题非常重要，是面试的高频问题，一定要牢记于心啊！！！

🔥🔥🔥如何在java中创建线程

线程其实是属于操作系统中的概念，操作系统会提供api，供程序员调用，但是不同的操作系统其实对应的api是不同的，java中jvm已经替我们将这些api封装好了，我们只需要关注jvm中的这一套api就好了。
一般我们通过使用Thread这个类来完成多线程的开发。

`🗼🗼🗼继承Thread重写Run方法创建线程`

class MyThread extends Thread{@Overridepublic void run() {System.out.println("Thread hello");}
}
public class Demo2 {public static void main(String[] args) {MyThread t=new MyThread();t.start();System.out.println("main hello");}
}

这里的run函数的主体其实就是我们完成线程主体任务的地方，在这里实现代码的主体部分，然后通过start方法，真正在内存中创建一个线程，通过回调函数run执行相关操作。回调函数就是用户手动定义了，但是没有手动调用，但是最后被系统调用的函数。

`🗼🗼🗼实现Runnable创建线程`

class MyRunnable implements Runnable{@Overridepublic void run() {while(true){System.out.println("hello thread");try{Thread.sleep(1000);}catch (InterruptedException e){throw new RuntimeException(e);}}}
}
public class Demo3 {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);}}
}

这里的sleep是Thread中的库函数，可以不导入包直接调用，但是这里存在一个受查异常，所以要进行异常捕捉。由于父类中的run方法并没有这个异常所以我们只能利用try-catch，而不能把异常向上抛出。

`🗼🗼🗼继承Thread利用匿名内部类实现一个线程`

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);}}

匿名内部类定义在一个类的内部，只能使用一次。

`🗼🗼🗼实现Runnable利用匿名内部类创建线程`

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);}}}});while (true) {System.out.println("hello main");Thread.sleep(1000);}}

`🗼🗼🗼利用lamda表达式创建一个线程`

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