系统编程——并发

已于 2023-05-03 17:06:11 修改
阅读量91 收藏
点赞数
文章标签： linux
于 2023-04-29 23:22:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhw19970108/article/details/130438088
版权

信号实现并发

同步
异步/并发：何时发生？什么结果？都是未知的
异步时间的处理：

  • 查询法：不断询问事件的发生（适合高频率）
  • 通知法：事件发生的时候反馈（适合低频率）
  1. 信号是什么？概念
    信号的软件中断
    信号的响应有依赖于中断
    中断是个硬件概念
  2. void (*signal(*int signum，void (*func)(int)))(int); 信号的发出函数
    命令 kill -l
    1-34标准信号 34-…
    多数的作用都是终止+core (core文件)

ulimit -a 看一下core文件大小，默认是0，因为经常出现段错误，会产生很多

信号会打断阻塞的系统调用

#include <signal.h>

typedef void (*sighandler_t)(int); // 函数指针重名为sighandler_t
sighandler_t signal(int signum, sighandler_t handler);

  1. 信号的不可靠
    信号行为不可靠，执行现场是内核布置，第一次调用没有结束，第二次调用开始了，第二次结果会将第一次结果覆盖：localtime

  2. 可重入函数
    第一次调用没有结束，第二次调用开始了，但是不会出错，就是可重入
    所有的系统调用都是可重入的，一部分库函数也是可重入的（尤其是返回值是指针类型的函数），eg：memcpy拷贝内存空间 _r后缀的函数

  3. 信号的响应过程
    信号从收到到响应有一个不可避免的延迟
    信号如何忽略掉一个信号的？
    标准信号为什么要丢失？
    标准信号的响应，没有严格的顺序

在这里插入图片描述

答1：信号的忽略的做法，就是将umask的该位置设置成0，那么&之后永远都是0，不会被响应

答2：每次接收信号都是将pending的那个信号位置设置为1，如果连续来多个同一个信号，他们的作用都是将那一位设置为1，多个来也没有作用，这是标准信号丢失的原因

  1. 信号常用函数
  • kill(); kill - send a signal to a process
// 成功返回0 失败返回-1，修改errno
int kill(pid_t pid, int sig); // pid >0 发送给pid进程
// pid = 0  发送给同组每一个进程（组内广播）
// pid = -1 发送给当前进程有权限发送的 每一个进程（除了init）本质只有init会使用
// pid < -1 发送给|pid|组内的所有进程
//  sig为0 就是没有信号
  • raise();
 #include <signal.h>
int raise(int sig); // 给自己进程发信号
  • alarm(); // 可以实现每秒。。。即流量控制
    alarm函数的默认作用是到达时间后，调用该函数的进程终止，但是一般情况下调用进程都会捕获该信号，
    如果想捕捉SIGALRM信号，则必须在调用alarm之前安装该信号的处理程序，
    如果先调用alarm，然后在我们能够安装SIGALRM处理程序之前已经接到该信号，那么进程将终止（摘取自apue 第三版p268）

pause函数使调用进程挂起，直到捕捉到一个信号，继续执行,eg捕获一个ALRM信号

 #include <unistd.h>
unsigned int alarm(unsigned int seconds); // 计时为0时会发送alarm信号

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    alarm(5); // 5s后发送 alarm信号，会杀死当前进程

    alarm(1);

    alarm(5);

    
    while (1)
    {
        /* code */
    }
    

    return 0;
}

实现一个cat

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>

#include <sys/stat.h>
#include <sys/types.h>

#define CPS 10
#define BUFFSIZE CPS

static volatile int loop = 0;

static void alrm_handler(int s)
{
    alarm(1); // 第一次执行的时候，发出下一次执行的时钟信号
    loop = 1;
}

int main(int argc, char ** argv)
{   
    if (argc < 2)
    {
        fprintf(stdout, "usage");
        exit(1);
    }

    signal(SIGALRM, alrm_handler); // 接收时钟信号，
    alarm(1); // 一秒钟发一个时钟信号 1s后会执行时钟处理函数

    int sfd = 1;
    int dfd = 1;
    do
    {
        // 信号检查
        sfd = open(argv[1], O_RDONLY);
        if (sfd < 0)
        {
            if (errno != EINTR)
            {
                strerror(errno);
                exit(1);
            }
        }
    } while (sfd < 0);
    

    // const int SIZE = 8192;
    char buf[BUFFSIZE];
    int count = 0;
    while (1)
    {
        // loop初始导致这里阻塞 1s之后
        while (!loop)
        {
            pause(); // loop == 0  当alrm信号到来时，会打断pause系统调用，再次查看循环条件
        }
        loop = 0;  // 死循环下次再到while的时候，又pause，等待时钟信号到来，再跳出执行读写
        int len = 0; // read 返回值
        int ret = 0; // write 返回值
        int pos = 0; // 写截止的位置
        while ((len = read(sfd, buf, BUFFSIZE)) < 0)
        {
            if (len < 0)
            {
                if (errno == EINTR)
                    continue;
                
                strerror(errno);
                break;
            }
        }
        if (len == 0)
        {
            break;
        }

        // 防止写入不足
        while (len > 0)
        {
            ret = write(dfd, buf + pos, len); // 读出的结果写入到目标文件中
            if (ret < 0)
            {
                if (errno == EINTR)
                    continue;
                printf("%s\n", strerror(errno));
                exit(1);
            }
            pos += ret;
            len -= ret;
        }
        count++;
    }
    // printf("%d\n", count);
    close(sfd);
    return 0;
}

令牌桶实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>

#include <sys/stat.h>
#include <sys/types.h>

#define CPS 10
#define BUFFSIZE CPS
#define BURST 100
// 上限，最大积攒100个字节，每次是10个字节

// 令牌桶实例

static volatile sig_atomic_t token = 0; // 信号原子类型，这种类型的修改，机器会保证都是原子操作

static void alrm_handler(int s)
{
    alarm(1); // 第一次执行的时候，发出下一次执行的时钟信号
    token++;
    if (token > BURST)
    {
        token = BURST;
    }
}

int main(int argc, char ** argv)
{   
    if (argc < 2)
    {
        fprintf(stdout, "usage");
        exit(1);
    }

    signal(SIGALRM, alrm_handler); // 接收时钟信号
    alarm(1); // 一秒钟发一个时钟信号 1s后会执行时钟处理函数  发出第一个alrm信号

    int sfd = 1;
    int dfd = 1;
    do
    {
        // 信号检查
        sfd = open(argv[1], O_RDONLY);
        if (sfd < 0)
        {
            if (errno != EINTR)
            {
                strerror(errno);
                exit(1);
            }
        }
    } while (sfd < 0);
    

    // const int SIZE = 8192;
    char buf[BUFFSIZE];
    int count = 0;
    while (1)
    {
        // token初始导致这里阻塞 1s之后
        while (token <= 0) // 没有字节就等着
        {
            pause(); // 等待有信号打断pause 1s之后打断
        }
        // 累加
        token--;  // 执行一次 ， 读10 写10 消耗一个令牌
        int len = 0; // read 返回值
        int ret = 0; // write 返回值
        int pos = 0; // 写截止的位置
        while ((len = read(sfd, buf, BUFFSIZE)) < 0) // token的作用在这里，如果时钟信号打断，token会增加到23445...积攒处理次数
        {
            if (len < 0)
            {
                if (errno == EINTR)
                    continue;
                
                strerror(errno);
                break;
            }
        }
        if (len == 0)
        {
            break;
        }

        // 防止写入不足
        while (len > 0)
        {
            ret = write(dfd, buf + pos, len); // 读出的结果写入到目标文件中
            if (ret < 0)
            {
                if (errno == EINTR)
                    continue;
                printf("%s\n", strerror(errno));
                exit(1);
            }
            pos += ret;
            len -= ret;
        }
        count++;
    }
    // printf("%d\n", count);
    close(sfd);
    return 0;
}

使用单一计时器，构造一组函数，实现任意数量的计时器

  • abort();
  • system();
  • sleep();
  1. 信号集
  2. 信号屏蔽字/判定集的处理
  3. 扩展
  • sigsuspend();
#include <signal.h>
int sigsuspend(const sigset_t *mask);

信号驱动程序

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

static void int_handler(int s)
{
    write(1, "!", 1);// 终端输出一个！
}

int main()
{
    sigset_t set, oset, saveset;
    signal(SIGINT, int_handler); // 发出中断信号的时候，打印一个!

    sigemptyset(&set);
    sigaddset(&set, SIGINT);

    sigprocmask(SIG_UNBLOCK, &set, &saveset); // 保存当前场景的做法，一般使用UNBLOCK，把set中的信号unblock，把之前的状态存到saveset中
    sigprocmask(SIG_BLOCK, &set, &oset); // 保存当前场景的做法，一般使用UNBLOCK，把set中的信号unblock，把之前的状态存到saveset中
    for (int j = 0; j < 1000; j++)
    {
        // sigprocmask(SIG_BLOCK, &set, &oset); // 对信号集合中的信号进行屏蔽，集合中只有中断信号，保存当前信号集到oset
        sigprocmask(SIG_BLOCK, &set, NULL); 

        // 执行不受到影响---不响应
        for (int i = 0; i < 5; i++)
        {
            write(1, "*", 1); // 1的fd1
            sleep(1);
        }
        write(1, "\n", 1); // 1的fd1
        sigsuspend(&oset); // 一旦解除oset信号集阻塞，立即进入等待状态
        // sigset_t tmpset;
        // sigprocmask(SIG_SETMASK, &oset, &tmpset);
        // pause();
        // sigprocmask(SIG_SETMASK, &tmpset, NULL);
    }
    sigprocmask(SIG_SETMASK, &saveset, NULL); // 与保存状态方法互补，恢复saveset之前的状态
    return 0;
}
  • sigaction();
 #include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

// 对signum信号定义新的行为 sigaction，保存旧的信号行为oladact不保存也可以为空


 struct sigaction {
     void     (*sa_handler)(int); // 信号处理函数
     void     (*sa_sigaction)(int, siginfo_t *, void *); // 
     sigset_t   sa_mask; // 在响应信号的时候，将一个集合的信号阻塞住
     int        sa_flags;
     void     (*sa_restorer)(void);
};



// siginfo_t 

 siginfo_t {
	    int      si_signo;     /* Signal number */
	    int      si_errno;     /* An errno value */
	    int      si_code;      /* Signal code */
	    // 常用
	    ...
}

流量控制，仅内核信号可中断，使用sigaction，setitimer函数重构

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/time.h>

#include "mytbf.h"

// 结构体隐藏到.c中编译成库
struct mytbf_st
{
    int cps;
    int burst;
    int token;
    int pos;
};

// typedef void (*sighandler_t)(int);  // 标准中抽象出来是，要实现重命名
// static sighandler_t alrm_handler_save;
static int inited = 0;

static struct mytbf_st* job[MTBF_MAX];

void static alrm_action(int s, siginfo_t* infop, void* used)
{
    // 仅仅响应内核信号
    if (infop->si_code != SI_KERNEL)
    {
        return;
    }
    // alarm(1);
    for (int i = 0; i < MTBF_MAX; i++)
    {
        // 有任务存在
        if (job[i] != NULL)
        {
            job[i]->token += job[i]->cps;
            if (job[i]->token < job[i]->burst)
            {
                job[i]->token = job[i]->burst;
            }
        }
    }
}

static struct sigaction alrm_sa_save;

static void module_unload(void)
{
    // signal(SIGALRM, alrm_handler_save); // 恢复
    // alarm(0);

    struct itimerval itv;

    sigaction(SIGALRM, &alrm_sa_save, NULL); // 恢复

    itv.it_interval.tv_sec = 0;
    itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec = 0;
    itv.it_value.tv_usec = 0;

    setitimer(ITIMER_REAL, &itv,NULL);

    for (int i = 0; i < MTBF_MAX; i++)
    {
        free(job[i]);
    }
}

static void module_load()
{
    // alrm_handler_save = signal(SIGALRM, alrm_handler); // 被修改的信号返回
    // alarm(1);
    struct sigaction sa;
    struct itimerval itv;

    sa.sa_sigaction = alrm_action;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO; // 第三个参数，表示使用的是三参的处理函数
    
    if (sigaction(SIGALRM,&sa, &alrm_sa_save) < 0) // 第三个参数是保存
    {
        perror("");
        exit(2);
    }


    itv.it_interval.tv_sec = 1;
    itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec = 1;
    itv.it_value.tv_usec = 0;
    setitimer(ITIMER_REAL, &itv, NULL);
    atexit(module_unload); // 钩子函数
}

static int min(int a, int b)
{
    return a < b ? a : b;
}

static int get_free_pos(void)
{
    for (int i = 0; i < MTBF_MAX; i++)
    {
        if (job[i] == NULL)
        {
            return i;
        }
    }
    return -1;
}

mytbf_t* mytbf_init(int cps, int burst)
{
    struct mytbf_st *me;
    if (inited == 0)
    {
        module_load();
        inited = 1;
    }

    int pos = get_free_pos();
    if (pos < 0)
    {
        // 没有空位了
        return NULL;
    }
    me = malloc(sizeof(*me));
    if (me == NULL)
    {
        return NULL;
    }
    me->token = 0;
    me->burst =  burst;
    me->cps = cps;
    me->pos = pos;
    job[pos] = me; // 把一个结构体指针存放入数组
    return me;
}

int mytbf_fetchtoken(mytbf_t* ptr, int size)
{
    struct mytbf_st *me = ptr;

    if (size <= 0)
        return -1;

    while (me->token <= 0)
        pause();

    int n = min(me->token, size);
    me->token -= n;
    return n;
}

int mytbf_returntoken(mytbf_t *ptr, int size)
{
    struct mytbf_st *me = ptr;

    if (size <= 0)
        return -1;

    me->token += size;

    if (me->token > me->burst)
        me->token = me->burst;

    return size;
}

int mytbf_destory(mytbf_t *ptr)
{
    struct mytbf_st *me = ptr;
    job[me->pos] = NULL;
    free(ptr);
}

重构守护进程

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <syslog.h>
#include <signal.h>


#define FNAME "/tmp/out"

static int daemonize(void)
{
    FILE* fd;
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork");
        exit(1);
    }
    else if (pid > 0)
    {
        exit(0); // 父进程退出
    }
    else
    {
        // 脱离终端 012需要重定向  不能定向到终端
        fd = open("dev/null", O_RDWR);
        if (fd < 0)
        {
            perror("open");
            return (-1);
        }
        // 守护进程打开文件，使其具有文件描述符012， 任何一个读写err的库例程都不会产生效果
        dup2(fd, 0);  // 文件输入输出重定向
        dup2(fd, 1);
        dup2(fd, 2);
        if (fd < 2)
            close(fd);

        setsid(); // 子进程设置为守护进程 
        chdir("/"); // 工作路径设置到根目录 因为从父进程继承来的工作目录可能是个挂载的目录，
        // 如果守护进程的工作目录也是一个挂载目录，那么该文件系统将不可以被卸载
        // umask(0);
        return 0;
    }
}

static FILE* fp;
static int daemon_exit(int s)
{
    // 此信号处理函数是可重入的，就是在处理一个信号的时候，另一个信号也来了(通过底层的&运算)，
    // 那么此时如果刚刚执行fclose，没有closelog的执行，响应了另一个信号，再次进入到该信号处理函数中，
    // 解决方法：在进入信号处理函数的时候，将其他信号屏蔽，处理结束的时候，在解除屏蔽sigprocmask
    fclose(fp);
    closelog();
    exit(1);
}

int main()
{
    // 必须使用规定信号才可以杀死该进程

    // signal(SIGINT,daemon_exit);
    // signal(SIGQUIT,daemon_exit);
    // signal(SIGTREM,daemon_exit);
    struct sigaction sa;
    sa.sa_handler = daemon_exit; // 第一个参数 第二个是三个参数的信号处理函数，暂时不考虑
    sigemptyset(&sa.sa_mask); // 第三个参数  执行处理函数期间，被屏蔽的信号集
    sigaddset(&sa.sa_mask, SIGQUIT);
    sigaddset(&sa.sa_mask, SIGTERM);
    sigaddset(&sa.sa_mask, SIGINT);  // 响应SIGINT的时候，SIGINT的mask位是0，再将其加入到屏蔽集合中，只不过是再次的设置一次0
    sa.sa_flags = 0; // 第四个参数，一般用不到，先设置为0

    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL); // 三个信号驱动，这三个信号都可以实现阻塞进程
    sigaction(SIGQUIT, &sa, NULL);
    //      一般使用pid   守护进程类别
    openlog("mydaemon", LOG_PID, LOG_DAEMON);
    // 守护进程
    if (daemonize())
    {
        syslog(LOG_ERR, "init failed");
    }
    else
    {
        syslog(LOG_INFO, "successed");
    }

    // 守护进程做的任务
    fp = fopen(FNAME, "w+");
    if (fp == NULL)
    {
        syslog(LOG_ERR, "write file failed");
        exit(1);
    }

    syslog(LOG_INFO, "%s opened", FNAME);
    for (int i = 0; ;i++)
    {
        fprintf(fp, "%d", i);
        fflush(NULL);
        syslog(LOG_INFO, "%d wrote", i);
        sleep(1);
    }
    closelog();   // 执行不到，因为都是异常终止
    fclose(fp);

    return 0;
}
  • setitimer();
    更精确的时间控制时间
int getitimer(int which, struct itimerval *curr_value);
int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);

 struct itimerval {
      struct timeval it_interval; /* Interval for periodic timer */
       struct timeval it_value;    /* Time until next expiration */
   };

   struct timeval {
       time_t      tv_sec;         /* seconds */
       suseconds_t tv_usec;        /* microseconds */
   };
  1. 实时信号
    解决标准信号的不足，响应有顺序，同时到来是先响应标准信号的

多线程实现并发

晗光。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java并发编程——内存模型
02-24
并发——在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行——源自百度百科在并发编程中，我们需要...
并发编程——并发工具类.pdf
06-06
关于java中线程的一些基础知识详解文档和知识点，内容详细，通俗易懂，非常适合当接触线程知识的同学，以及复习线程理论知识人员
并发编程——JUC知识脑图
庄小焱
05-16 1008
摘要 并发编程在软件编程中尤为突出和重要，在当今面试或工作中也是不可缺少的。作为一名高级java开发工程师，并发编程的技能已经成为了重要的一项。本博文将详细介绍并发编程中的知识点和知识脑图，帮助大家更好的学习和使用的并发编程。 一、并发编程知识脑图 二、并发编程知识详细解析 2.1 JUC并发编程知识脑图 并发编程——知识脑图_庄小焱的博客-CSDN博客 2.2 JUC并发大厂面试问题 并发编程——JUC并发大厂面试问题_庄小焱的博客-CSDN博客_并发编程常见问题 2.3 JU
JAVA并发编程——并发容器
传臣、的博客
01-15 237
为什么JUC需要提供并发容器 Java提供了丰富的容器，有map、list、set、queue、deque。但是其存在一个不足：多数容器类都是非线程安全的，即使部分容器是线程安全的，由于使用sychronized进行锁控制，导致读/写均需进行锁操作，性能很低。 为了提供高效地并发容器，java 5在java.util.cocurrent包中 引入了并发容器。 JUC并发容器 java并发编程——并...
java并发编程——并发理论基础
shao1996的博客
10-09 166
互斥：同一时间只允许一个线程访问共享资源（如，可重入锁）同步：多个线程协同工作（countDownLatch）分工：拆解任务并分配给线程(fork/Join)
并行编程——并发级别
sun
12-29 3525
1、扩展Thread类2、实现Runnable接口3.两者区别采用继承Thread类方式： （1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。 （2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。 采用实现Runnable接口方式： （1）优点： 线程类只是实现了Run
并发操作之——并发编程三要素
weixin_42397937的博客
09-04 8653
并发操作 并发操作之——并发编程三要素。 并发操作之——并发编程三要素并发操作前言一、原子性二、有序性:三、可见性:总结 前言 并发操作之——并发编程三要素。 一、原子性 一个不可再被分割的颗粒，原子性指的是一个或多个操作要么全部执行成功要么全部执行失败，期间不能被中断，也不存在上下文切换，线程切换会带来原子性的问题 ​ int num = 1; // 原子操作 num++; // 非原子操作，从主内存读取num到线程工作内存，进行 +1，再把num写到主内存, 除非用原子类，即java.util.
Java并发编程——Synchronized
qq_43284141的博客
04-26 135
原理 这篇大佬的讲的还是比较详细了：深入理解Java并发之synchronized实现原理 然后记住几幅图：
并发编程——Volatile关键字
u014112521的专栏
02-07 407
volatile概述 简单的cpu内存模型 三大特性 volatile的原理，应用以及volatile与synchronized的对比
并发操作之——并发编程实践
weixin_42397937的博客
09-17 3203
并发操作 并发操作之——BlockingQueue. 并发操作之——BlockingQueue并发操作一、编程里面解决生产消费者模型的几种方式1、wait() / notify()方法2、await() / signal()方法3、Semaphore信号量4、BlockingQueue阻塞队列二、synchronized和ReenTrantLock的使用场景1、synchronized2、ReenTrantLock总结 一、编程里面解决生产消费者模型的几种方式 核心：要保证生产者不会在缓冲区满时放入数
Go语言并发编程——原子操作
m0_62969222的博客
09-30 1930
而互斥锁实现的操作，当前执行Goroutine是会被其它Goroutine抢占的，但是其它的Goroutine在未获取锁的情况并不能顺利执行，从而保证了并发的安全性。同样的，在未使用原子写时，可能写到一半的数据被读到，所以要保证并发的安全性，要同时保证读和写的原子性，或者使用互斥锁保证读和写之间互斥，写和写之间也互斥。在非原子读时，可能会造成：读到一半Goroutine被中断，当Goroutine再次被调度时，数据已被修改，那么最终读出来的就是一个奇怪的值。原子操作能够使用的场景很少，是有很大局限性的。
C#并发编程——并发编程技术
weixin_30548917的博客
08-31 166
并发编程技术 并发编程技术并发的基本概念并发技术——多线程并发技术——异步编程并发技术——并行编程并发技术——响应式编程并发技术——TPL数据流并发编程的集合技术要点总结 并发的基本概念 并发，即同时做几件事。但是并发并不只是多线程，多线程只是并发的一种形式，还有很多并发技术，比如异步，并行，TPL数据流，响应式编程等。 并发技术——多线程 多线程是并发的一种形式，建议尽量使用...
Java并发编程总结——慎用CAS详解
09-02
Java并发编程中，CAS（Compare and Swap，比较并交换）是一种无锁算法，常用于实现原子操作，它在多线程环境下提供了数据的一致性。然而，CAS并不是万能的，过度依赖或不当使用可能会导致问题。下面我们将深入探讨...
并发编程——线程基础.pdf
06-06
关于java中线程的一些基础知识详解文档和知识点，内容详细，通俗易懂，非常适合当接触线程知识的同学，以及复习线程理论知识人员
Linux小程序——进度条
最新发布
m0_66182473的博客
07-23 668
进度条
Linux：基础命令学习
qq_55038440的博客
07-20 896
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
linux学习笔记整理: 关于linux:Shell脚本 2024/7/20；
gzx233的博客
07-20 883
Shell脚本的使用
【Linux服务器Java环境搭建】010在linux中安装Redis，以及对Redis的配置与远程连接
liuzhenhe1988的专栏
07-19 1012
好久没有更新博客了，今天下了班回到家，看到电脑桌上尘封已久的《Spring Boot应用开发实战》，翻开目录想起来之前写的系列【Linux服务器Java环境搭建】还未完结，那就继续吧，今天主要是按linux服务器中安装和配置redis。本系列其他文章，请查看系列【Linux服务器Java环境搭建】
Linux 权限
includemainprinf的博客
07-18 687
在Linux操作系统中，权限管理是一个至关重要的概念，它确保了系统的安全性和稳定性。同时可以在工作中，设置对象的权限，就算我们很多人使用一台服务器，我们也可以让别人看不到我们文件的内容，或者让别人无法对自己的文件进行操作！
深入理解Java并发编程——基石篇精华总结
"Java 并发——基石篇.pdf" 这篇PDF文档是关于Java并发编程的基石篇，作者在知乎上发布过相关文章，但为了更好的阅读体验和无字数限制，整理成了PDF格式。文档涵盖了Java并发的基础知识，包括线程、同步机制、对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值