Linux知识点 -- 进程间通信（二）

Linux知识点 – 进程间通信（二）

文章目录

  • Linux知识点 -- 进程间通信（二）
  • 一、System V共享内存
    • 1.原理
    • 2.申请共享内存
    • 3.System V共享内存的使用
    • 4.为共享内存添加访问控制
  • 二、信号量（概念理解）
    • 1.概念
    • 2.信号量

一、System V共享内存

1.原理

在这里插入图片描述
先在内存中申请空间，然后将这段空间映射到不同进程的地址空间中，这就叫做共享内存；
一般都是映射在进程的堆栈之间的共享区；
共享内存不属于任何一个进程，它属于操作系统；
操作系统对共享内存的管理，是先描述再组织，先通过内核数据结构描述共享内存的属性信息，再将它们组织起来；
共享内存 = 共享内存块 + 对应的共享内存的内核数据结构；
共享区属于用户空间，不用经过系统调用，直接可以访问；
双方进程如果要通信，直接进行内存级的读写即可；
之前的管道是一种文件。是OS中的一种数据结构，所以用户无权直接访问，需要进行系统调用；

2.申请共享内存

在这里插入图片描述
shmget接口能够申请共享内存；

  • 参数：
    key：通信双方的进程，通过key值来保证是通信的双方来创建的共享内存，相当于一个验证值，需要在系统内是唯一的，通信双方使用同一个key；
    size：内存大小，一般是页（4byte）的整数倍；
    shmflag：有两个选项：IPC_CREAT和IPC_EXCL；
    IPC_CREAT能单独出现，代表如果共享内存已存在，则获取之；如果不存在，就创建之，并返回；
    IPC_EXCL必须和IPC_CREAT组合使用，代表如果共享内存不存在，就创建之，并返回；如果已存在，出错并返回；
    0就代表IPC_CREAT；
    返回值：成功会返回共享内存id，失败返回-1；

ftok函数：生成唯一的key
在这里插入图片描述

  • 参数：
    ==pathname：==文件路径，一定要保证用户有权限；
    ==id：==项目id，随便给，一般是0 - 255；
    返回值：成功，返回key值；失败，返回-1；
    ftok会拿路径文件的inode，和id形成一个唯一的key，生成结果是有可能重复的；

3.System V共享内存的使用

  • Makefile：
.PHONY:all
all:shmClient shmServer

shmServer:shmServer.cc
	g++ -o $@ $^ -std=c++11 
shmClient:shmClient.cc
	g++ -o $@ $^ -std=c++11 

.PHONY:clean
claen:
	rm -f shmServer shmClient
  • Log.hpp
#ifndef _LOG_H_
#define _LOG_H_

#include<iostream>
#include<ctime>

#define DeBug   0
#define Notice  1
#define Waring  2
#define Error   3

const std::string msg[] = {
    "DeBug",
    "Notice",
    "Waring",
    "Error"
};

std::ostream &Log(std::string message, int level)
{
    std::cout << " | " << (unsigned)time(nullptr) << " | " << msg[level] << " | " << message;
    return std::cout;
}
#endif
  • comm.hpp
#ifndef _COMM_H_
#define _COMM_H_

#include<iostream>
#include<cstdio>
#include<unistd.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<cassert>
#include "Log.hpp"

using namespace std;

#define PATH_NAME "/usr/lmx" //路径，一定保证有权限
#define PROJ_ID 0X66   
#define SHM_SIZE 4096 //共享内存大小，最好是页（4byte）的整数倍

#endif
  • shmServer.cc
    #include “comm.hpp”

string TransToHex(key_t k)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), “0x%x”, k);
return buffer;
}

int main()
{
// 1.创建公共的key值
key_t key = ftok(PATH_NAME, PROJ_ID);
if (key == -1)
{
perror(“ftok”);
exit(1);
}

Log("creat key done", DeBug) << "server key : " << TransToHex(key) << endl;

// 2.创建共享内存 -- 建议创建一个全新的共享内存 -- 通信的发起者
int shmid = shmget(key, SHM_SIZE, IPC_CREAT | IPC_EXCL | 0666);
if (shmid == -1)
{
    perror("shmget");
    exit(2);
}
Log("shm creat done", DeBug) << "shmid : " << shmid << endl;

//3.将指定的共享内存，挂接到自己的地址空间
char* shmaddr = (char*)shmat(shmid, nullptr, 0);
Log("attach shm done", DeBug) << "shmid : " << shmid << endl;

//这里就是通信逻辑了
//将共享内存看作一个大字符串
//shmaddr就是这个字符串的起始地址
for(;;)
{
    printf("%s\n", shmaddr);//不断打印这个字符串的内容
    if(strcmp(shmaddr, "quit") == 0)
    {
        break;
    }
    sleep(1);
}

//4.将指定的共享内存，从自己的地址空间中去关联
int n = shmdt(shmaddr);
if(n == -1)
{
    perror("shmdt");
    exit(3);
}
Log("detach shm done", DeBug) << "shmid : " << shmid << endl;

//5.删除共享内存，IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存
n = shmctl(shmid, IPC_RMID, nullptr);
if(n == -1)
{
    perror("shmctl");
    exit(4);
}
Log("delete shm done", DeBug) << "shmid : " << shmid << endl;

return 0;

}

注意：
（1）
在这里插入图片描述
要保证创建出唯一的key；*
（2）
在这里插入图片描述
创建全新的共享内存，0666代表共享内存的权限；
共享内存的大小最好是页的整数倍，否则会造成空间浪费，多开空间，但是没有权限访问；
在这里插入图片描述
第二次创建的时候，提示共享内存已存在；
在这里插入图片描述
（3）ipcs -m：查看共享内存信息；
在这里插入图片描述
ipcrm -m shmid：删除共享内存（不能用key删除）
共享内存的生命周期随内核;
与文件不一样，文件的生命周期，如果进程退出，没有其他进程再关联这个文件，那么就会被回收;
在这里插入图片描述
在这里插入图片描述
perms属性就是共享内存的权限，

（4）因此，当进程结束后，共享内存还存在，我们继续要删除它，使用系统接口：
shmctl：删除共享内存
在这里插入图片描述
在这里插入图片描述
（5）nattch属性是挂接的共享内存个数，共享内存创建好之后，需要挂接在自己的进程地址空间；
shmat：挂接共享内存
在这里插入图片描述
参数：
shmid：共享内存id
shmaddr：挂接虚拟地址，直接设为0，让os挂接
shmflg：挂接方式
返回值：成功返回共享内存addr虚拟地址，失败返回-1
使用：
将返回值作为共享内存的起始地址；
在这里插入图片描述
shmdt：去关联
在这里插入图片描述
参数：
shmaddr：共享内存地址
返回值：成功返回0，失败返回-1

  • shmClient.cc
#include "comm.hpp"

int main()
{
    // 客户端也获取key
    key_t key = ftok(PATH_NAME, PROJ_ID);
    if (key < 0)
    {
        Log("creat key failed", Error) << "client key : " << key << endl;
        exit(1);
    }
    Log("creat key done", DeBug) << "client key : " << key << endl;

    // 获取共享内存
    int shmid = shmget(key, SHM_SIZE, 0);
    if (shmid == -1)
    {
        Log("creat shm failed", Error) << "client key : " << key << endl;
        exit(2);
    }
    Log("creat shm done", DeBug) << "client key : " << key << endl;


    // 挂接共享内存
    char *shmaddr = (char *)shmat(shmid, nullptr, 0);
    if (shmaddr == nullptr)
    {
        Log("attach shm failed", Error) << "client key : " << key << endl;
    }
    Log("attach shm done", DeBug) << "client key : " << key << endl;
    
    // 使用
    //client将共享内存看作一个char类型的buffer
    //客户端从键盘读取消息，直接读到共享内存中
    while (true)
    {
        ssize_t s = read(0, shmaddr, SHM_SIZE - 1);
        if(s > 0)
        {
            shmaddr[s - 1] = 0;
            if(strcmp(shmaddr, "quit") == 0)//读到quit，客户端退出
            {
                break;
            }
        }
    }
    
    // char a = 'a';
    // for(; a <= 'z'; a++)
    // {
    //     //每一次都向shmaddr（共享内存的起始地址）写入
    //     snprintf(shmaddr, SHM_SIZE - 1, 
    //             "hello server, 我是其他进程，我的pid： %d, inc: %c\n", 
    //             getpid(), a);
    //     sleep(2);
    // }

    // 去关联
    int n = shmdt(shmaddr);
    if (n == -1)
    {
        perror("shmdt");
        exit(3);
    }
    Log("detach shm done", DeBug) << "client key : " << key << endl;

    // client不需要删除shm

    return 0;
}

注意：
（1）共享内存的使用，直接将共享内存看作一个char类型的buffer，直接向里面写入数据
在这里插入图片描述
从stdin中键盘读取消息，直接读取到shmaddr这个地址，即共享内存的起始地址；

运行结果：
服务端：
在这里插入图片描述
客户端：
在这里插入图片描述

  • 注：
    （1）只要是通信双方使用shm，一方直接向共享内存中写入数据，另一方就可以立马看到对方写入的数据；共享内存是所有进程间通信中最快的，不需要过多的拷贝；
    （2）管道通信中，一次通信需要多次拷贝，用户从键盘输入数据到缓冲区是一次拷贝，从缓冲区向管道文件写入数据又是一次拷贝，从管道文件向缓冲区读取数据是一次拷贝，从缓冲区将数据打印又是一次拷贝；
    在这里插入图片描述

（3）共享内存只需要两次拷贝，从键盘输入的数据直接写入shm，这是一次拷贝，直接将shm的数据打印出来，这是第二次拷贝；
在这里插入图片描述

4.为共享内存添加访问控制

从上面的结果可以看出，即便是客户端还没有挂接共享内存，服务端就已经开始不停读取数据了，这就表明共享内存是不带访问控制的，会带来一定的并发问题；
然而，管道是自带访问控制的，我们可以利用管道通信来为共享内存添加访问控制；
comm.hpp

#ifndef _COMM_H_
#define _COMM_H_

#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <cassert>
#include <cstring>
#include <sys/stat.h>
#include <fcntl.h>
#include "Log.hpp"

using namespace std;

#define PATH_NAME "/home/lmx" // 路径，一定保证有权限
#define PROJ_ID 0X66
#define SHM_SIZE 4096 // 共享内存大小，最好是页（4byte）的整数倍

#define FIFO_NAME "./fifo"

class Init
{
public:
    Init()
    {
        umask(0);
        int n = mkfifo(FIFO_NAME, 0666);
        assert(n == 0);
        (void)n;
        Log("creat fifo succsee", Notice) << "\n";
    }

    ~Init()
    {
        unlink(FIFO_NAME);
        Log("remove fifo succsee", Notice) << "\n";
    }
};


#define READ O_RDONLY
#define WRITE O_WRONLY

int OpenFIFO(std::string pathname, int flags)
{
    int fd = open(pathname.c_str(), flags);
    assert(fd >= 0);
    return fd;
}

void Wait(int fd)
{
    Log("waiting...", Notice) << "\n";
    uint32_t temp = 0;
    ssize_t s = read(fd, &temp, sizeof(uint32_t));
    assert(s == sizeof(uint32_t));
    (void)s;
}

void Signal(int fd)
{
    uint32_t temp = 1;
    ssize_t s = write(fd, &temp, sizeof(uint32_t));
    assert(s == sizeof(uint32_t));
    (void)s;
    Log("aweaking...", Notice) << "\n";
}

void CloseFIFO(int fd)
{
    close(fd);
}

#endif

注：
（1）创建了一个类，类的构造函数有创建管道文件，一旦类实例化出对象，调用构造函数，就能够创建一个管道文件，后面就是对管道文件的读写控制了；
在这里插入图片描述
shmServer.cc

#include "comm.hpp"

string TransToHex(key_t k)
{
    char buffer[32];
    snprintf(buffer, sizeof(buffer), "0x%x", k);
    return buffer;
}

int main()
{
    Init init;
    // 对应的程序在加载的时候，会自动构建全局变量，就要调用该类构造函数 -- 创建管道文件
    // 程序退出的时候，全局变量会被析构，会自动删除管道文件

    // 1.创建公共的key值
    key_t key = ftok(PATH_NAME, PROJ_ID);
    if (key == -1)
    {
        perror("ftok");
        exit(1);
    }

    Log("creat key done", DeBug) << "server key : " << TransToHex(key) << endl;

    // 2.创建共享内存 -- 建议创建一个全新的共享内存 -- 通信的发起者
    int shmid = shmget(key, SHM_SIZE, IPC_CREAT | IPC_EXCL | 0666);
    if (shmid == -1)
    {
        perror("shmget");
        exit(2);
    }
    Log("shm creat done", DeBug) << "shmid : " << shmid << endl;

    // 3.将指定的共享内存，挂接到自己的地址空间
    char *shmaddr = (char *)shmat(shmid, nullptr, 0);
    Log("attach shm done", DeBug) << "shmid : " << shmid << endl;

    // 这里就是通信逻辑了
    // 将共享内存看作一个大字符串
    // shmaddr就是这个字符串的起始地址

    //使用管道进行访问控制
    int fd = OpenFIFO(FIFO_NAME, READ);

    for (;;)
    {
        Wait(fd);//等待客户端响应，
                    //使用管道文件的访问控制，如果客户端没有向管道内写入数据，那么该进程会一直阻塞
        printf("%s\n", shmaddr); // 不断打印这个字符串的内容
        if (strcmp(shmaddr, "quit") == 0)
        {
            break;
        }
        sleep(1);
    }

    CloseFIFO(fd);

    // 4.将指定的共享内存，从自己的地址空间中去关联
    int n = shmdt(shmaddr);
    if (n == -1)
    {
        perror("shmdt");
        exit(3);
    }
    Log("detach shm done", DeBug) << "shmid : " << shmid << endl;

    // 5.删除共享内存，IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存
    n = shmctl(shmid, IPC_RMID, nullptr);
    if (n == -1)
    {
        perror("shmctl");
        exit(4);
    }
    Log("delete shm done", DeBug) << "shmid : " << shmid << endl;

    return 0;
}

注：
（1）在服务端先创建一个管道文件
在这里插入图片描述
（2）在读取共享内存中的数据前，先读取管道数据，看客户端是否响应；
在这里插入图片描述
shmClient.cc

#include "comm.hpp"

int main()
{
    // 客户端也获取key
    key_t key = ftok(PATH_NAME, PROJ_ID);
    if (key < 0)
    {
        Log("creat key failed", Error) << "client key : " << key << endl;
        exit(1);
    }
    Log("creat key done", DeBug) << "client key : " << key << endl;

    // 获取共享内存
    int shmid = shmget(key, SHM_SIZE, 0);
    if (shmid == -1)
    {
        Log("creat shm failed", Error) << "client key : " << key << endl;
        exit(2);
    }
    Log("creat shm done", DeBug) << "client key : " << key << endl;


    // 挂接共享内存
    char *shmaddr = (char *)shmat(shmid, nullptr, 0);
    if (shmaddr == nullptr)
    {
        Log("attach shm failed", Error) << "client key : " << key << endl;
    }
    Log("attach shm done", DeBug) << "client key : " << key << endl;
    
    // 使用
    //client将共享内存看作一个char类型的buffer
    //客户端从键盘读取消息，直接读到共享内存中

    //使用管道进行访问控制
    int fd = OpenFIFO(FIFO_NAME, WRITE);

    while (true)
    {
        ssize_t s = read(0, shmaddr, SHM_SIZE - 1);
        if(s > 0)
        {
            shmaddr[s - 1] = 0;
            Signal(fd);//向管道写入数据
            if(strcmp(shmaddr, "quit") == 0)//读到quit，客户端退出
            {
                break;
            }
        }
    }

    CloseFIFO(fd);
    
    // 去关联
    int n = shmdt(shmaddr);
    if (n == -1)
    {
        perror("shmdt");
        exit(3);
    }
    Log("detach shm done", DeBug) << "client key : " << key << endl;

    // client不需要删除shm

    return 0;
}

注：
（1）在向共享内存写入数据前，先向管道写入信号，表明客户端准备写入数据，唤醒服务端：
在这里插入图片描述

运行结果：
当运行服务端，但是客户端未响应时，服务端会等待客户端响应，进程阻塞；
在这里插入图片描述
当客户端响应时，服务端会被唤醒，读取共享内存中的数据：
在这里插入图片描述
退出：
在这里插入图片描述

二、信号量（概念理解）

1.概念

  • 基于对共享内存的理解：
    为了让进程间通信，让不同的进程之间，看到同一份资源，我们之前讲的所有的进程间通信都是基于这种方式；
    而让不同的进程看到同一份资源，比如共享内存，也带来了一些时序问题，会造成数据的不一致

  • 概念
    （1）临界资源：多个进程（执行流）看到的公共的一份资源；
    （2）临界区：自己的进程，访问临界资源的代码；
    （3）互斥：为了更好的进行临界区的维护，可以让多执行流在任何时刻，都只能有一个进程进入临界区；
    （4）原子性：要么不做，要么做完，没有中间状态；

2.信号量

我们平常看电影前，会先买票，电影院中的座位就相当于资源，当你买了票，这个座位就真正属于你，买票的本质就是对座位的预定机制；
对于进程来说，访问临界资源中的一部分，不能让进程直接去使用临界资源，需要先申请信号量；
信号量的本质是一个计数器；

  • 申请信号量：
    （1）申请信号量的本质，就是让信号量技术器 - -；
    （2）申请信号量成功，临界资源内部，一定给进程预留了需要的资源，申请信号量的本质就是对临界资源的一种预定机制；

  • 释放信号量：
    释放信号量就是将计数器++；

如果将信号量计数器设为全局变量（整数n，存放在共享内存），让多个进程看到同一个全局变量，大家都能够进行信号量的申请，这样是不行的；
因为CPU在执行n++这个指令的时候，其实执行了三条语句：
（1）将内存中的数据加载到CPU内的寄存器（读指令）；
（2）n–（执行指令）；
（3）将CPU修改完毕的值再写入内存（写指令）；
而执行流在执行的时候，在任何时刻都是能被切换的；
例如：
如果信号量刚开始是5，client在申请信号量的时候，第一步就被切换了，寄存器里的数据保存为上下文数据，
由server申请信号量，如果server将信号量减到2了，此时server被切换，client回来
client回来的时候就会将上下文数据恢复，将信号量恢复为5，再申请信号量，这时信号量就变为了4；

寄存器只有一套，被所有执行流共享，但是寄存器内的数据，属于每一个执行流，属于该执行流的上下文数据；
这样设计，会导致信号量是不安全的；
因此，申请和释放信号量这两个操作，必须是原子的；
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/63205.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

JVM 调优

JVM 调优

点击下方关注我&#xff0c;然后右上角点击...“设为星标”&#xff0c;就能第一时间收到更新推送啦~~~ JVM调优是一项重要的任务&#xff0c;可以提高Java应用程序的性能和稳定性。掌握JVM调优需要深入了解JVM的工作原理、参数和配置选项&#xff0c;以及历史JVM参数的调整和优…
阅读更多...
K8S系列文章 之 容器网络基础 Docker0

K8S系列文章 之 容器网络基础 Docker0

什么是Docker0 使用ip addr命令看一下网卡&#xff1a; rootKitDevVps:~# ip addr 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00inet 127.0.0.1/8 scope host…
阅读更多...
数据结构之栈和队列---c++

数据结构之栈和队列---c++

栈和队列的简单介绍 栈 栈是一个“先进后出”结构 队列 入队演示 队列是一种“先进先出”的结构 出队演示 接下来我们开始本次的内容 栈实现队列 分析 1.我们可以老老实实的写一个栈然后将所有的接口函数实现出来&#xff0c;最后再进行实现队列&#xff0c;但是显然…
阅读更多...
集中/本地转发、AC、AP

集中/本地转发、AC、AP

1.ADSL ADSL MODEM&#xff08;ADSL 强制解调器&#xff09;俗称ADSL猫 ADSL是一种异步传输模式&#xff08;ATM)。ADSL是指使用电话线上网&#xff0c;需要专用的猫&#xff08;Modem)&#xff0c;在上网的时候高频和低频分离&#xff0c;所以上网电话两不耽误&#xff0c;速…
阅读更多...
合并果子C++详解

合并果子C++详解

题目描述 在一个果园里&#xff0c;多多已经将所有的果子打了下来&#xff0c;而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。 每一次合并&#xff0c;多多可以把两堆果子合并到一起&#xff0c;消耗的体力等于两堆果子的重量之和。可以看出&#xff0c;…
阅读更多...
【MCU学习】GD32F427VG开发

【MCU学习】GD32F427VG开发

&#xff08;一&#xff09;学习文档和例程 兆易创新GD32 MCU参考资料下载 1.GD232F4xx的Keil芯片支持包 2.标准固件库和示例程序 3.GD32F4xx_固件库使用指南_Rev1.2 4.用户手册&#xff1a;GD32F4xx_User_Manual_Rev2.8_CN 5.数据手册&#xff1a;GD32F427xx_Datasheet_Rev…
阅读更多...
Ansible环境搭建，CentOS 系列操作系统搭建Ansible集群环境

Ansible环境搭建，CentOS 系列操作系统搭建Ansible集群环境

Ansible是一种自动化工具&#xff0c;基于Python写的&#xff0c;原理什么的就不过多再说了&#xff0c;详情参考&#xff1a;https://www.itwk.cc/post/403.html https://blog.csdn.net/qq_34185638/article/details/131079320?spm1001.2014.3001.5502 环境准备 HOSTNAMEIP…
阅读更多...
为react项目添加开发/提交规范（前端工程化、eslint、prettier、husky、commitlint、stylelint）

为react项目添加开发/提交规范（前端工程化、eslint、prettier、husky、commitlint、stylelint）

因历史遗留原因&#xff0c;接手的项目没有代码提醒/格式化&#xff0c;包括 eslint、pretttier&#xff0c;也没有 commit 提交校验&#xff0c;如 husky、commitlint、stylelint&#xff0c;与其期待自己或者同事的代码写得完美无缺&#xff0c;不如通过一些工具来进行规范和…
阅读更多...
22.Netty源码之解码器

22.Netty源码之解码器

highlight: arduino-light 抽象解码类 https://mp.weixin.qq.com/s/526p5f9fgtZu7yYq5j7LiQ 解码器 Netty 常用解码器类型&#xff1a; ByteToMessageDecoder/ReplayingDecoder 将字节流解码为消息对象&#xff1b;MessageToMessageDecoder 将一种消息类型解码为另外一种消息类…
阅读更多...
AI赋能转型升级 助力打造“数智辽宁”——首次大模型研讨沙龙在沈成功举行

AI赋能转型升级 助力打造“数智辽宁”——首次大模型研讨沙龙在沈成功举行

当前&#xff0c;以“ChatGPT”为代表的大模型正在引领新一轮全球人工智能技术发展浪潮&#xff0c;推动人工智能从以专用小模型定制训练为主的“手工作坊时代”&#xff0c;迈入以通用大模型预训练为主的“工业化时代”&#xff0c;正不断加速实体经济智能化升级&#xff0c;深…
阅读更多...
K8S系列文章之 离线安装自动化工具Ansible

K8S系列文章之 离线安装自动化工具Ansible

参考 文档 离线安装 Ansible - DevOps - dbaselife 一、Ansible简介 Ansible是一款开源的IT配置管理工具&#xff0c;常被IT界的小伙伴们用于自动化的场景&#xff0c;多用在服务部署、配置管理方面。配置文件采用最常见的yaml格式&#xff0c;学习起来也是比较容易&#xff…
阅读更多...
从0开始全栈深度学习工程师之路（四）：VSCode提效设置和插件

从0开始全栈深度学习工程师之路（四）：VSCode提效设置和插件

在从0开始深度学习工程师之路&#xff08;三&#xff09;&#xff1a;Python开发环境搭建&#xff08;VSCode) 中,我们一步步搭建了基于VSCode的开发环境&#xff0c;这一篇我们继续优化我们的开发环境&#xff0c;毕竟工欲善其事&#xff0c;必先利其器。 配置 同步设置 我…
阅读更多...
《HeadFirst设计模式(第二版)》第三章代码——装饰者模式

《HeadFirst设计模式(第二版)》第三章代码——装饰者模式

代码文件结构&#xff1a; 星巴兹案例&#xff1a; CondimentDecorator package Chapter3_DecorativeObjects.Decorators;import Chapter3_DecorativeObjects.Beverage;/*** Author 竹心* Date 2023/8/3**/public abstract class CondimentDecorator extends Beverage {Bever…
阅读更多...
数智保险 创新未来 | GBASE南大通用亮相中国保险科技应用高峰论坛

数智保险 创新未来 | GBASE南大通用亮相中国保险科技应用高峰论坛

本届峰会以“数智保险 创新未来”为主题&#xff0c;GBASE南大通用携新一代创新数据库产品及金融信创解决方案精彩亮相&#xff0c;与国内八百多位保险公司高管和众多保险科技公司技术专家&#xff0c;就保险领域数字化的创新应用及生态建设、新一代技术突破及发展机遇、前沿科…
阅读更多...
空地协同智能消防系统——无人机、小车协同

空地协同智能消防系统——无人机、小车协同

1 题目 1.1 任务 设计一个由四旋翼无人机及消防车构成的空地协同智能消防系统。无人机上安装垂直向下的激光笔&#xff0c;用于指示巡逻航迹。巡防区域为40dm48dm。无人机巡逻时可覆盖地面8dm宽度区域。以缩短完成全覆盖巡逻时间为原则&#xff0c;无人机按照规划航线巡逻。发…
阅读更多...
Ubuntu安装JDK与IntelliJ IDEA

Ubuntu安装JDK与IntelliJ IDEA

目录 前言 Ubuntu 安装 JDK 1、更新软件包列表 2、安装OpenJDK 3、验证安装 Ubuntu安装IntelliJ IDEA 1、下载 IntelliJ IDEA 2、解压缩 IntelliJ IDEA 安装包 3、移动 IntelliJ IDEA 到安装目录 4、启动 IntelliJ IDEA 前言 APT&#xff08;Advanced Package Tool&…
阅读更多...
-bash: ./startup.sh: Permission denied解决

-bash: ./startup.sh: Permission denied解决

今天在Linux上启动Tomcat&#xff0c;结果弹出&#xff1a;-bash: ./startup.sh: Permission denied 的提示。 这是因为用户没有权限&#xff0c;而导致无法执行。用命令chmod 修改一下bin目录下的.sh权限就可以了。 在Tomcat的bin目录下 &#xff0c;输入命令行 &#xff1a;c…
阅读更多...
MyBatis关联查询

MyBatis关联查询

文章目录 前言多对一关联 association一对多关联 collectionresultMap元素 前言 提示&#xff1a;这里可以添加本文要记录的大概内容&#xff1a; 关联查询是指在一个查询中同时获取多个表中的数据&#xff0c;将它们结合在一起进行展示。 关联表需要两个及以上的表 数据库代…
阅读更多...
升级你的GitHub终端认证方式：从密码到令牌

升级你的GitHub终端认证方式：从密码到令牌

升级你的GitHub终端认证方式&#xff1a;从密码到令牌 前言 GitHub官方在2021年8月14日进行了一次重大改变&#xff0c;它将终端推送代码时所需的身份认证方式从密码验证升级为使用个人访问令牌&#xff08;Personal Access Token&#xff09;。这个改变引起了一些新的挑战&am…
阅读更多...
java网络编程概述及例题

java网络编程概述及例题

网络编程概述 计算机网络 把分布在不同地理区域的计算机与专门的外部设备用通信线路连成一个规模大、功能强的网络系统&#xff0c;从而使众多的计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。 网络编程的目的 直接或间接地通过网络协议与其他计算机实现…
阅读更多...
最新文章

Copyright @ 2022~2023