多线程详解（一）

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量247 收藏
点赞数
文章标签： java 后端 线程安全 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51945098/article/details/121747354
版权

多线程

1.基本概念:程序、进程、线程

1.1 程序、进程、线程

1.1.1 程序

程序是为完成特定任务、用某种语言编写的一组指令的集合。
即指一段静态的代码，静态对象。

1.1.2 进程

进程是程序的一次执行过程，或是正在运行的一个程序。

是一个动态的过程:有它自身的产生、存在和消亡的过程。———生命周期
》程序是静态的，进程是动态的
》进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

1.1.3 线程

进程可进一步细化为线程，是一个程序内部的一条执行路径。

》若一个进程同一时间并行执行多个线程，就是支持多线程的
》线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小
》一个进程中的多个线程共享相同的内存单元/内存地址空间≥它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。
但多个线程操作共享的系统资源可能就会带来安全的隐患。

1.2 图示

在这里插入图片描述

1.3 题外话

1.3.1 单核CPU和多核CPU的区别：

单核CPU就是在相互切换，只不过速度太快了，
感觉不出来，所以本质上还是多核更好。

一个Java应用程序java.exe其实至少有三个线程:
main()主线程，gc()垃圾回收线程，异常处理线程。
当然如果发生异常，会影响主线程。

1.3.2 并行与并发

并行:
多个CPU同时执行多个任务。
比如:多个人同时做不同的事。

并发:
一个CPU(采用时间片)同时执行多个任务。
比如:秒杀、多个人做同一件事。

2.线程的创建和使用（重点）

2.1线程的创建和启动

Java语言的JVM允许程序运行多个线程，
它通过java.lang.Thread类来体现。

2.1.1Thread类的特性

  1. 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
  2. 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

2.2多线程创建，方式一:继承于Thread类

2.2.1步骤

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类的run()
  3. 创建Thread类的子类的对象
  4. 通过此对象调用start():
    (1)启动当前线程（2）调用当前线程的run()

2.2.2举例：

/**
 * 例子： 遍历100以内的所有偶数
 */
//1.创建一个继承于Thread类的子类
class MyThread extends Thread{ //新的线程 分线程
    //2.重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {//主线程
        //3.创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start()
        t1.start();

//      t1.run();//问题一
//      t1.start();//问题二

//     问题二：解决方案，需要重新创建一个线程的对象
        new MyThread().start();

        //如下操作仍然是在main线程中执行
        for (int i = 0; i < 100; i++) {
            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + ":" +
                        i + "*********main()*********");
            }
        }
    }
}

执行顺序：
首先main方法主线程先进来 造对象调方法
调完以后开始执行另一个线程 独立执行 run
main里的循环还是在主线程接着往下执行
主线程和分线程同时执行 输出语句就不确定什么时候执行了

结果大概是：
main:0*********main()*********
main:2*********main()*********
main:4*********main()*********
Thread-1:0
Thread-0:0
Thread-1:2
main:6*********main()*********
Thread-1:4
。。。

问题一： 我们不能通过直接调用run()的方式启动线程。
t1.run();》还是单线程没有开辟新的线程 只是体现了对象调方法

问题二： 再启动一个线程，遍历100以内偶数
不可以还让已经start()的线程去执行。会报IllegalThreadStateException

对于线程来说 只能start一次

解决方案 ：需要重新创建一个线程的对象

2.2.3 优化

如果有多种功能，比如有两个分线程，这时候可以为了省事
》可以使用创建Thread类的匿名子类的方式

new Thread(){
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}.start();

//第二个根据第一个再次优化：
new Thread(() -> {
    for (int i = 0; i < 100; i++) {
        if (i % 2 !=0){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}).start();

2.3多线程创建，方式二:实现Runnable接口

2.3.1步骤

  1. 创建一个实现了Runnable接口的类
  2. 实现类去实现Runnable中的抽象方法: run()
  3. 创建实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中，
    创建Thread类的对象
  5. 通过Thread类的对象调用start():
    （1）启动线程
    （2）调用当前线程的run()–>调用了Runnable类型的target的run()

2.3.2举例：

/**
 * 创建多线程的方式二：实现Runnable接口
 */
//1.创建一个实现了Runnable接口的类
class MThread implements Runnable {
//2.实现类去实现Runnable中的抽象方法: run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
                //这边Thread.currentThread().不能省略
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5.通过Thread类的对象调用start(): 
       //1.启动线程 2.调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

2.4比较创建线程的两种方式：

开发中: 优先选择 ==》 实现Runnable接口的方式
选择的原因:
1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况。

联系: public class Thread implements Runnable

相同点: 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

举例 ：比如卖票，有几个窗口就有几个线程。
继承Thread类，票数必须要用static静态来表示，让票数处于共享，几个线程共用同一个票数。
而实现Runnable接口就不需要，天生就是共享数据，不过都有线程安全问题。

比如重票，错票，或者可能没按顺序卖票，
只是显示到页面的时候没及时显示出来 ，实际是按顺序的。

2.5测试Thread中的常用方法

2.5.1 方法：

  1. start():启动当前线程;调用当前线程的run()
  2. run():通常需要重写Thread类中的此方法，
    将创建的线程要执行的操作声明在此方法中
  3. currentThread():静态方法，返回执行当前代码的线程
  4. getName():获取当前线程的名字
  5. setName():设置当前线程的名字或者根据构造器来改名字
  6. yield():释放当前cpu的执行权 但谁能拿到还是不确定
  7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，
    直到线程b完全执行完以后，线程a才结束阻塞状态。
  8. stop():已过时。当执行此方法时，强制结束当前线程。
  9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。
    在指定的millitime毫秒时间内，当前线程是阻塞状态
  10. isAlive():判断当前线程是否存活

2.5.2 线程的优先级：

  1. MAX_ PRIORITY: 10
    MIN_ PRIORITY: 1
    NORM_ PRIORITY: 5 默认优先级

  2. 如何获取和设置当前线程的优先级
    （1）getPriority():获取线程的优先级
    （2）setPriority(int p):设置线程的优先级

说明:
高优先级的线程要抢占低优先级线程cpu的执行权。
但是只是从概率上讲，高优先级的线程高概率的情况下被执行。
并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。

2.5.3 举例：

class HelloThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 ==0){
//                try {
//                    sleep(10);//毫秒   1 秒=1000 毫秒
//                } catch (InterruptedException e) {  e.printStackTrace(); }
                System.out.println(Thread.currentThread().getName() + ":" + getPriority() + ":" + i);
                //Thread.currentThread().可以省略
            }
//            if (i % 20 == 0){  yield(); }
        }
    }
    public HelloThread(String name){ super(name); }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("Thread:1");
//        h1.setName("线程一");

        //设置分线程的优先级
        h1.setPriority(Thread.MAX_PRIORITY);

        h1.start();
//        给主线程命名
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i < 100; i++) {
            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
            }
//            if (i == 20) {
//                try {
//                    h1.join();
//                } catch (InterruptedException e) {e.printStackTrace();}
//            }
        }
        System.out.println(h1.isAlive());
    }
}

2.5.4 异常

Error:java:无效的行发行版：1.9
装了1.8的JDK 在 1.9 版本的环境跑 肯定抛错
在这里插入图片描述

3.线程的生命周期

3.1 生命周期

JDK中用Thread.State类定义了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。
Java语言使用Thread类及其子类的对象来表示线程，
在它的一个完整的生命周期中通常要经历如下的五种状态:

  1. 新建: 当一个Thread类或其子类的对象被声明并创建时，
    新生的线程对象处于新建状态

  2. 就绪: 处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，
    此时它已具备了运行的条件，只是没分配到CPU资源

  3. 运行: 当就绪的线程被调度并获得CPU资源时,便进入运行状态，
    run()方法定义了线程的操作和功能

  4. 阻塞: 在某种特殊情况下，被人为挂起或执行输入输出操作时，
    让出CPU并临时中止自己的执行，进入阻塞状态

  5. 死亡: 线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

3.2 图示

在这里插入图片描述

4.线程的同步（重点）

4.1 问题的引入：

多个线程执行的不确定性引起执行结果的不稳定

4.1.1 举例：

创建三个窗口卖票，总票数为100张【使用实现Runnable的方式】

问题 :
卖票过程中，出现了重票、错票–>出现了线程的安全问题

问题出现的原因:
当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

如何解决:
当一个线程a在操作ticket的时候，其他线程不能参与进来。
直到线程a操作完ticket时，其他线程才可以开始操作ticket。
这种情况即使线程a出现了阻塞，也不能被改变。

总结： 在Java中，我们通过同步机制，来解决线程的安全问题。

4.2 方式一: 同步代码块

4.2.1 代码：

 synchronized(同步监视器){ //需要被同步的代码 }

4.2.2 说明：

  1. 操作共享数据的代码，即为需要被同步的代码
    –>不能包含代码多了，也不能包含代码少了。
  2. 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
  3. 同步监视器，俗称：锁。 任何一个类的对象，都可以充当锁。
    要求： 多个线程必须要共用同一把锁。（唯一的）

补充:
在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

4.2.3 举例1：

使用同步代码块解决实现Runnable接口的线程安全问题

class Window1 implements Runnable {
    private int ticket = 100;
//    Object obj = new Object();
//    Dog dog = new Dog();
    @Override
    public void run() {
        while (true){
        //方式一：
            synchronized (this){
		//此时的this：唯一的window1的对象  当前对象
    	// 方式二： synchronized (dog) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                        //sleep 阻塞状态 线程二就进来的概率极大增加
						//会出现-1 0等等的概率大大增加          
                    } catch (InterruptedException e) { e.printStackTrace();  }
                    System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
                    ticket--;
                } else {  break;  }
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class Dog{}

注意：
如果synchronized(同步监视器){ } 写在while(true)外面，
那么就只有一个随机的线程进去，并且这个线程执行到完毕，
不会有其他的线程进去。

4.2.4 举例2：

使用同步代码块解决继承Thread类的方式的线程安全问题

说明:
在继承Thread类创建多线程的方式中，
慎用this充当同步监视器，
考虑使用当前类充当同步监视器。

class Window2 extends Thread{
    private static int ticket = 100;
    private static Object obj = new Object();
    @Override
    public void run() {
        while (true){
//            synchronized (obj) {
                //上面是正确的 下面是第二种方式
            synchronized (Window2.class){
            //类也是对象 Window2.class也是唯一的，只会加载一次
            // 下面是错的：this代表着t1,t2,t3三个对象
                //synchronized (this){
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + "：卖票，票号为：" + ticket);
                    ticket--;
                } else {  break; }
            }
        }
    }
}
public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

4.2 方式二: 同步方法

4.2.1 说明

如果操作共享数据的代码完整的声明在一个方法中，
我们不妨将此方法声明同步的。

4.2.2 举例1：

使用同步方法解决实现Runnable接口的线程安全问题

class Window3 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    public synchronized void show(){//同步监视器：this
//        synchronized (this) {
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
                ticket--;
            }
//        } 没有break 记得手动停止
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

4.2.3 举例2：

使用同步方法处理继承Thread类的方式中的线程安全问题

class Window4 extends Thread {
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {  show();  }
    }
    public static synchronized void show(){//同步监视器：Window4.class  唯一的
        //同步监视器： t1,t2,t3 不是唯一的this 这边 不能用synchronized 可以再加个static
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) { e.printStackTrace();}
            System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
            ticket--;
        }
//       没有break 记得手动停止
    }
}

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

4.2.4 关于同步方法的总结

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  2. 非静态的同步方法，同步监视器是: this
    静态的同步方法，同步监视器（即锁）是:当前类本身

4.3 同步的好坏

好处：
同步的方式，解决了线程的安全问题。

坏处（局限）：
操作同步代码时，只能有一个线程参与，其他线程等待。
相当于是一个单线程的过程，效率低。

好好学java的xz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java并发编程基础篇（一）之线程，附答案+考点
m0_64867092的博客
12-22 532
其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。 死亡状态 一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。 线程的优先级 每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。 public final void setPriority(int newPriority) ： 更改此线
Python多线程详解
01-27
线程有5种状态，状态转换的过程如下图所示：多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。考虑这样一种情况：一个列表里所有元素都是0，线程...
【译】最大限度地降低多线程 C# 代码的复杂性
weixin_30548917的博客
03-22 112
分支或多线程编程是编程时最难最对的事情之一。这是由于它们的并行性质所致，即要求采用与使用单线程的线性编程完全不同的思维模式。对于这个问题，恰当类比就是抛接杂耍表演者，必须在空中抛接多个球，而不要让它们相互干扰。这是一项重大挑战。然而，通过正确的工具和思维模式，这项挑战是能应对的。 本文将深入介绍我为了简化多线程编程和避免争用条件、死锁等其他问题而编写的一些工具。可以说，工具链以语法糖和...
java 线程题目_java多线程题目01
weixin_33265716的博客
02-21 132
题目：两个线程交替顺序打印，一个输出正整数1到52，一个输出a-zA-Z,例如 -1a2b3c4d5e6f7g8h9i10j11k12l13m14n15o16p17q18r19s20t21u22v23w24x25y26z27A28B29C30D31E32F33G34H35I36J37K38L39M40N41O42P43Q44R45S46T47U48V49W50X51Y52Z一、使用volatil...
一文详解C++多线程
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
C#高级--多线程详解
李宥的博客
10-03 4万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java多线程详解
坏蛋阿土的博客
11-06 6597
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
python多线程详解（超详细）
热门推荐
世俗的眼光
03-30 21万+
python中的多线程是一个非常重要的知识点，今天为大家对多线程进行详细的说明，代码中的注释有多线程的知识点还有测试用的实例。 import threading from threading import Lock,Thread import time,os ''' python多线程详解 什么是线程？ ...
QT多线程编程详解
coolboywjun的专栏
04-24 8万+
一、线程基础 1、GUI线程与工作线程 每个程序启动后拥有的第一个线程称为主线程，即GUI线程。QT中所有的组件类和几个相关的类只能工作在GUI线程，不能工作在次线程，次线程即工作线程，主要负责处理GUI线程卸下的工作。 2、数据的同步访问 每个线程都有自己的栈，因此每个线程都要自己的调用历史和本地变量。线程共享相同的地址空间。 二、QT多线程简介 QT通过三种形式提供了对线程...
Java多线程详解及示例
07-20
在多线程环境下，死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是指线程不断重试获取资源，但由于其他线程持有资源不释放，导致线程陷入无限循环的状态。避免死锁和活锁的关键在于...
狂神说多线程详解.rar
05-06
《狂神说多线程详解》是一份深入探讨多线程技术的资源包，其中包含了对多线程编程的详尽解析。多线程是现代计算机编程中的一个重要概念，尤其在处理高性能计算、并发操作以及实时系统时，多线程技术显得尤为重要。它...
JAVA进阶补充
2301_80150315的博客
08-15 896
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 589
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1054
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 368
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
旅游网站
weixin_43213064的博客
08-16 790
【代码】springboot旅游网站
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值