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

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

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

由此我们发明了一个新的并发编程的形式，线程（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{
    @Override
    public 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{
    @Override
    public 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(){
            @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);
        }
    }

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

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

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

好了，今天就分享这么多了，感兴趣的话关注不迷路哦