转 https://www.jianshu.com/p/2c4caed49343

消息队列之 Kafka

2018.01.15 16:27* 字数 3533 阅读 1114评论 0喜欢 12

Kafka 特点

Kafka 最早是由 LinkedIn 公司开发一种分布式的基于发布/订阅的消息系统,之后成为 Apache 的顶级项目。主要特点如下:

  1. 同时为发布和订阅提供高吞吐量
    Kafka 的设计目标是以时间复杂度为 O(1) 的方式提供消息持久化能力,即使对TB 级以上数据也能保证常数时间的访问性能。即使在非常廉价的商用机器上也能做到单机支持每秒 100K 条消息的传输。

  2. 消息持久化
    将消息持久化到磁盘,因此可用于批量消费,例如 ETL 以及实时应用程序。通过将数据持久化到硬盘以及 replication 防止数据丢失。

  3. 分布式
    支持 Server 间的消息分区及分布式消费,同时保证每个 partition 内的消息顺序传输。这样易于向外扩展,所有的producer、broker 和 consumer 都会有多个,均为分布式的。无需停机即可扩展机器。

  4. 消费消息采用 pull 模式
    消息被处理的状态是在 consumer 端维护,而不是由 server 端维护,broker 无状态,consumer 自己保存 offset。

  5. 支持 online 和 offline 的场景。
    同时支持离线数据处理和实时数据处理。

Kafka 中的基本概念

  1. Broker
    Kafka 集群中的一台或多台服务器统称为 Broker

  2. Topic
    每条发布到 Kafka 的消息都有一个类别,这个类别被称为 Topic 。(物理上不同
    Topic 的消息分开存储。逻辑上一个 Topic 的消息虽然保存于一个或多个broker上,但用户只需指定消息的 Topic 即可生产或消费数据而不必关心数据存于何处)

  3. Partition
    Topic 物理上的分组,一个 Topic 可以分为多个 Partition ,每个 Partition 是一个有序的队列。Partition 中的每条消息都会被分配一个有序的 id(offset)

  4. Producer
    消息和数据的生产者,可以理解为往 Kafka 发消息的客户端

  5. Consumer
    消息和数据的消费者,可以理解为从 Kafka 取消息的客户端

  6. Consumer Group
    每个 Consumer 属于一个特定的 Consumer Group(可为每个 Consumer 指定Group Name,若不指定 Group Name 则属于默认的 Group)。
    这是 Kafka 用来实现一个 Topic 消息的广播(发给所有的 Consumer )和单播(发给任意一个 Consumer )的手段。一个
    Topic 可以有多个 Consumer Group。Topic 的消息会复制(不是真的复制,是概念上的)到所有的 Consumer
    Group,但每个 Consumer Group 只会把消息发给该 Consumer Group 中的一个
    Consumer。如果要实现广播,只要每个 Consumer 有一个独立的 Consumer Group 就可以了。如果要实现单播只要所有的
    Consumer 在同一个 Consumer Group 。用 Consumer Group 还可以将 Consumer
    进行自由的分组而不需要多次发送消息到不同的 Topic 。

Kafka 安装

Mac 用户用 HomeBrew 来安装,安装前要先更新 brew

brew update

接着安装 kafka

brew install kafka

安装完成之后可以查看 kafka 的配置文件

cd /usr/local/etc/kafka
kafka 配置文件

我的电脑通过 HomeBrew 安装的 kafka 位置在 /usr/local/Cellar/kafka/0.11.0.1/bin ,可以看到 HomeBrew 安装下来的 kafka 的版本已经是 0.11.0.1 的了。

kafka 需要用到 zookeeper,HomeBrew 安装kafka 的时候会同时安装 zookeeper。下面先启动 zookeeper:

zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties

接着启动 kafka

cd /usr/local/Cellar/kafka/0.11.0.1
./bin/kafka-server-start /usr/local/etc/kafka/server.properties

创建 topic,设置 partition 数量为2,topic 的名字叫 test-topic,下面的例子都用这个 topic

cd /usr/local/Cellar/kafka/0.11.0.1
./bin/kafka-topics --create --zookeeper localhost:2181 --replication-factor 1 --partitions 2 --topic test-topic

查看创建的 topic

cd /usr/local/Cellar/kafka/0.11.0.1
./bin/kafka-topics --list --zookeeper localhost:2181

Kafka 命令行测试

发送消息

cd /usr/local/Cellar/kafka/0.11.0.1/bin
kafka-console-producer --broker-list localhost:9092 --topic test-topic

消费消息

cd /usr/local/Cellar/kafka/0.11.0.1/bin
kafka-console-consumer --bootstrap-server localhost:9092 --topic test-topic --from-beginning

删除 topic

cd /usr/local/Cellar/kafka/0.11.0.1/bin
./bin/kafka-topics --delete --zookeeper localhost:2181 --topic test-topic

如果 kafka 启动时加载的配置文件中 server.properties 没有配置delete.topic.enable=true,那么此时的删除并不是真正的删除,而是把 topic 标记为:marked for deletion

可以通过命令来查看所有 topic

cd /usr/local/Cellar/kafka/0.11.0.1/bin
./bin/kafka-topics --zookeeper localhost:2181 --list

如果想真正删除它,可以如下操作

登录zookeeper客户端:/usr/local/Cellar/zookeeper/3.4.10/bin/zkCli
找到topic所在的目录:ls /brokers/topics
找到要删除的topic,执行命令:rmr /brokers/topics/test-topic 即可,此时topic被彻底删除

Java 客户端访问

  1. maven工程的pom文件中添加依赖
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>0.11.0.1</version>
</dependency>
  1. 消息生产者
package org.study.kafka;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord; import java.util.HashMap;
import java.util.Map; public class ProducerSample { public static void main(String[] args) {
Map<String, Object> props = new HashMap<String, Object>();
props.put("zk.connect", "127.0.0.1:2181");//zookeeper 的地址
props.put("bootstrap.servers", "localhost:9092");//用于建立与 kafka 集群连接的 host/port 组。
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); String topic = "test-topic";
Producer<String, String> producer = new KafkaProducer<String, String>(props);
producer.send(new ProducerRecord<String, String>(topic, "idea-key2", "java-message 1"));
producer.send(new ProducerRecord<String, String>(topic, "idea-key2", "java-message 2"));
producer.send(new ProducerRecord<String, String>(topic, "idea-key2", "java-message 3")); producer.close();
} }
  1. 消息消费者
package org.study.kafka;

import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer; import java.util.Arrays;
import java.util.Properties; public class ConsumerSample { public static void main(String[] args) {
String topic = "test-topic";// topic name Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");//用于建立与 kafka 集群连接的 host/port 组。
props.put("group.id", "testGroup1");// Consumer Group Name
props.put("enable.auto.commit", "true");// Consumer 的 offset 是否自动提交
props.put("auto.commit.interval.ms", "1000");// 自动提交 offset 到 zookeeper 的时间间隔,时间是毫秒
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
Consumer<String, String> consumer = new KafkaConsumer(props);
consumer.subscribe(Arrays.asList(topic));
while (true) {
ConsumerRecords<String, String> records = consumer.poll(100);
for (ConsumerRecord<String, String> record : records)
System.out.printf("partition = %d, offset = %d, key = %s, value = %s%n", record.partition(), record.offset(), record.key(), record.value());
} }
}
  1. 启动 zookeeper
zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties
  1. 启动 kafka 服务器
kafka-server-start /usr/local/etc/kafka/server.properties
  1. 运行 Consumer
    先运行 Consumer ,这样当生产者发送消息的时候能在消费者后端看到消息记录。
  2. 运行 Producer
    运行 Producer,发布几条消息,在 Consumer 的控制台能看到接收的消息

    Consumer 控制台

Kafka 集群配置

kafka 的集群配置一般有三种,即: single node - single broker ,single node - multiple broker ,multiple node - multiple broker

前两种实际上官网有介绍

  • single node - single broker

    单节点单 broker
  1. 启动 zookeeper
zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties
  1. 启动 kafka broker
kafka-server-start /usr/local/etc/kafka/server.properties
  1. 创建一个 kafka topic
kafka-topics --create --zookeeper localhost:2181 --replication-factor 1 --partitions 2 --topic topic-singlenode-singlebroker
  1. 启动 producer 发送信息
kafka-console-producer --broker-list localhost:9092 --topic topic-singlenode-singlebroker

broker-list 和 topic 这两个参数是必须的,broker-list 指定要连接的 broker 的地址,格式为 node_address:port 。topic 是必须的,因为需要发送消息给订阅了该
topic 的 consumer group 。
现在可以在命令行里输入一些信息,每一行会被作为一个消息。

发送消息
  1. 启动 consumer 消费消息
kafka-console-consumer --bootstrap-server localhost:9092 --topic topic-singlenode-singlebroker

在不同的终端窗口里分别启动 zookeeper、broker、producer、consumer 后,在
producer 终端里输入消息,消息就会在 consumer 终端中显示了。

消息显示
  • single node - multiple broker

    单节点多 broker
  1. 启动 zookeeper
zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties
  1. 启动broker

如果需要在单个节点(即一台机子)上面启动多个 broker(这里作为例子启动三个 broker),需要准备多个server.properties文件即可,所以需要复制 /usr/local/etc/kafka/server.properties 文件。因为需要为每个 broker 指定单独的属性配置文件,其中 broker.id 、 port 、 log.dir 这三个属性必须是不同的。

新建一个 kafka-example 目录和三个存放日志的目录

mkdir kafka-example
mkdir kafka-logs-1
mkdir kafka-logs-2
mkdir kafka-logs-3

复制 /usr/local/etc/kafka/server.properties 文件三份

cp server.properties /Users/niwei/Downloads/kafka-example/server-1.properties
cp server.properties /Users/niwei/Downloads/kafka-example/server-2.properties
cp server.properties /Users/niwei/Downloads/kafka-example/server-3.properties

在 broker1 的配置文件 server-1.properties 中,相关要修改的参数为:

broker.id=1
port=9093
log.dirs=/Users/niwei/Downloads/kafka-example/kafka-logs-1

broker2 的配置文件 server-2.properties 中,相关要修改的参数为:

broker.id=2
port=9094
log.dirs=/Users/niwei/Downloads/kafka-example/kafka-logs-2

broker3 的配置文件 server-3.properties 中,相关要修改的参数为:

broker.id=3
port=9095
log.dirs=/Users/niwei/Downloads/kafka-example/kafka-logs-3

启动每个 broker

cd /Users/niwei/Downloads/kafka-example
kafka-server-start server-1.properties
kafka-server-start server-2.properties
kafka-server-start server-3.properties
  1. 创建 topic

创建一个名为 topic-singlenode-multiplebroker 的topic

kafka-topics --create --zookeeper localhost:2181 --replication-factor 3 --partitions 1 --topic topic-singlenode-multiplebroker
  1. 启动 producer 发送信息
    如果一个 producer 需要连接多个 broker 则需要传递参数 broker-list
kafka-console-producer --broker-list localhost:9093, localhost:9094, localhost:9095 --topic topic-singlenode-multiplebroker
  1. 启动 consumer 消费消息
kafka-console-consumer --zookeeper localhost:2181 --topic topic-singlenode-multiplebroker
单节点多 broker 消费消息
  • multiple node - multiple broker

    多节点多 broker

    在多节点多 broker 集群中,每个节点都需要安装 Kafka,且所有的 broker 都连接到同一个 zookeeper 。这里 zookeeper 当然也是可以配置成集群方式的,具体步骤参见我之前写的搭建 zookeeper 集群

  1. Kafka 的集群配置
broker.id=1  #当前机器在集群中的唯一标识
port=9093 #当前 kafka 对外提供服务的端口,默认是 9092
host.name=192.168.121.101 #这个参数默认是关闭的,在0.8.1有个bug,DNS解析问题,失败率的问题。
log.dirs=/Users/niwei/Downloads/kafka-example/kafka-logs-1 #消息存放的目录,这个目录可以配置为逗号分割的表达式
zookeeper.connect=192.168.120.101:2181,192.168.120.102:2181,192.168.120.103:2181 #设置 zookeeper 集群的连接端口 num.network.threads=3 #这个是 borker 进行网络处理的线程数
num.io.threads=5 #这个是 borker 进行 IO 处理的线程数
socket.send.buffer.bytes=102400 #发送缓冲区的大小,数据先回存储到缓冲区了到达一定的大小后在发送能提高性能
socket.receive.buffer.bytes=102400 #接收缓冲区的大小,当数据到达一定大小后在序列化到磁盘
socket.request.max.bytes=104857600 #这个参数是向 kafka 请求消息或者向 kafka 发送消息的请求的最大数,这个值不能超过 jvm 的堆栈大小
num.partitions=1 #默认的分区数,一个 topic 默认1个分区数
log.retention.hours=24 #默认消息的最大持久化时间,24小时
message.max.byte=5242880 #消息保存的最大值5M
default.replication.factor=2 #kafka 保存消息的副本数,如果一个副本失效了,另一个还可以继续提供服务
replica.fetch.max.bytes=5242880 #取消息的最大直接数
log.segment.bytes=1073741824 #这个参数是因为 kafka 的消息是以追加的形式落地到文件,当超过这个值的时候,kafka 会新建一个文件
log.retention.check.interval.ms=300000 #每隔 300000 毫秒去检查上面配置的 log 失效时间(log.retention.hours=24 ),到目录查看是否有过期的消息如果有则删除
log.cleaner.enable=false #是否启用 log 压缩,一般不用启用,启用的话可以提高性能

由于是多节点多 broker 的,所以每个 broker 的配置文件 server.properties 都要按以上说明修改

  1. producer 的配置修改
kafka-console-producer --broker-list 192.168.21.1:9092,192.168.21.2:9092,192.168.21.3:9092 --topic topic-multiplenode-multiplebroker
  1. consumer 的配置修改
kafka-console-consumer --zookeeper 192.168.120.101:2181,192.168.120.102:2181,192.168.120.103:2181 --topic topic-multiplenode-multiplebroker

Kafka 高可靠性配置

Kafka 提供了很高的数据冗余弹性,对于需要数据高可靠性的场景可以增加数据冗余备份数(replication.factor),调高最小写入副本数的个数(min.insync.replicas)等等,但是这样会影响性能。反之,性能提高而可靠性则降低,用户需要自身业务特性在彼此之间做一些权衡性选择。

要保证数据写入到 Kafka 是安全的、高可靠的,需要如下的配置:

  1. topic 的配置
    replication.factor>=3,即副本数至少是3个2<=min.insync.replicas<=replication.factor
  2. broker 的配置
    leader 的选举条件 unclean.leader.election.enable=false
  3. producer 的配置
    request.required.acks=-1,producer.type=sync

Kafka 高吞吐量的秘诀

消息中间件从功能上看就是写入数据、读取数据两大类,优化也可以从这两方面来看。

为了优化写入速度 Kafak 采用以下技术:

  1. 顺序写入
    磁盘大多数都还是机械结构(SSD不在讨论的范围内),如果将消息以随机写的方式存入磁盘,就需要按柱面、磁头、扇区的方式寻址,缓慢的机械运动(相对内存)会消耗大量时间,导致磁盘的写入速度与内存写入速度差好几个数量级。为了规避随机写带来的时间消耗,Kafka
    采取了顺序写的方式存储数据,如下图所示:

    顺序写

    每条消息都被append 到该 partition 中,属于顺序写磁盘,因此效率非常高。
    但这种方法有一个缺陷:没有办法删除数据。所以Kafka是不会删除数据的,它会把所有的数据都保留下来,每个消费者(Consumer)对每个 Topic 都有一个
    offset 用来表示读取到了第几条数据。

    消费消息

    上图中有两个消费者,Consumer1 有两个 offset 分别对应 Partition0、Partition1(假设每一个 Topic 一个
    Partition )。Consumer2 有一个 offset 对应Partition2 。这个 offset 是由客户端 SDK
    保存的,Kafka 的 Broker 完全无视这个东西的存在,一般情况下 SDK 会把它保存到 zookeeper 里面。
    如果不删除消息,硬盘肯定会被撑满,所以 Kakfa 提供了两种策略来删除数据。一是基于时间,二是基于 partition 文件大小,具体配置可以参看它的配置文档。
    即使是顺序写,过于频繁的大量小 I/O 操作一样会造成磁盘的瓶颈,所以 Kakfa 在此处的处理是把这些消息集合在一起批量发送,这样减少对磁盘 I/O 的过度操作,而不是一次发送单个消息。

  2. 内存映射文件
    即便是顺序写入硬盘,硬盘的访问速度还是不可能追上内存。所以 Kafka
    的数据并不是实时的写入硬盘,它充分利用了现代操作系统分页存储来利用内存提高I/O效率。Memory Mapped Files
    (后面简称mmap)也被翻译成内存映射文件,在64位操作系统中一般可以表示 20G 的数据文件,它的工作原理是直接利用操作系统的 Page
    来实现文件到物理内存的直接映射。完成映射之后对物理内存的操作会被同步到硬盘上(由操作系统在适当的时候)。
    通过 mmap 进程像读写硬盘一样读写内存,也不必关心内存的大小,有虚拟内存为我们兜底。使用这种方式可以获取很大的 I/O
    提升,因为它省去了用户空间到内核空间复制的开销(调用文件的 read 函数会把数据先放到内核空间的内存中,然后再复制到用户空间的内存中)
    但这样也有一个很明显的缺陷——不可靠,写到 mmap 中的数据并没有被真正的写到硬盘,操作系统会在程序主动调用 flush
    的时候才把数据真正的写到硬盘。所以 Kafka 提供了一个参数—— producer.type 来控制是不是主动 flush,如果Kafka
    写入到 mmap 之后就立即 flush 然后再返回 Producer 叫同步(sync);如果写入 mmap 之后立即返回,Producer
    不调用 flush ,就叫异步(async)。

  3. 标准化二进制消息格式
    为了避免无效率的字节复制,尤其是在负载比较高的情况下影响是显著的。为了避免这种情况,Kafka 采用由 Producer,Broker 和
    Consumer 共享的标准化二进制消息格式,这样数据块就可以在它们之间自由传输,无需转换,降低了字节复制的成本开销。

而在读取速度的优化上 Kafak 采取的主要是零拷贝

  1. 零拷贝(Zero Copy)的技术:
    传统模式下我们从硬盘读取一个文件是这样的

    文件传输到 Socket 的常规方式

    (1)操作系统将数据从磁盘读到内核空间的页缓存区
    (2)应用将数据从内核空间读到用户空间的缓存中
    (3)应用将数据写会内核空间的套接字缓存中
    (4)操作系统将数据从套接字缓存写到网卡缓存中,以便将数据经网络发出
    这样做明显是低效的,这里有四次拷贝,两次系统调用。
    针对这种情况 Unix 操作系统提供了一个优化的路径,用于将数据从页缓存区传输到 socket。在 Linux 中,是通过 sendfile
    系统调用来完成的。Java提供了访问这个系统调用的方法:FileChannel.transferTo
    API。这种方式只需要一次拷贝:操作系统将数据直接从页缓存发送到网络上,在这个优化的路径中,只有最后一步将数据拷贝到网卡缓存中是需要的。

    零拷贝方式传输到 Socket

    这个技术其实非常普遍,The C10K problem 里面也有很详细的介绍,Nginx 也是用的这种技术,稍微搜一下就能找到很多资料。
    Kafka 速度的秘诀在于它把所有的消息都变成一个的文件。通过 mmap 提高 I/O
    的速度,写入数据的时候是末尾添加所以速度最优;读取数据的时候配合sendfile 直接暴力输出。所以单纯的去测试 MQ 的速度没有任何意义,Kafka 的这种暴力的做法已经脱了 MQ 的底裤,更像是一个暴力的数据传送器。

消息队列之 Kafka的更多相关文章

  1. 消息队列与Kafka

    2019-04-09 关键词: 消息队列.为什么使用消息队列.消息队列的好处.消息队列的意义.Kafka是什么 本篇文章系本人就当前所掌握的知识关于 消息队列 与 kafka 知识点的一些简要介绍,不 ...

  2. redis 的消息队列 VS kafka

    redis push/pop VS pub/sub (1)push/pop每条消息只会有一个消费者消费,而pub/sub可以有多个 对于任务队列来说,push/pop足够,但真的在做分布式消息分发的时 ...

  3. 【知识点】同样是消息队列,Kafka凭什么速度那么快?

    同样是消息队列,Kafka凭什么速度那么快? 作者 | MrZhangxd Kafka的消息是保存或缓存在磁盘上的,一般认为在磁盘上读写数据是会降低性能的,因为寻址会比较消耗时间,但是实际上,Kafk ...

  4. Spring Cloud(7):事件驱动(Stream)分布式缓存(Redis)及消息队列(Kafka)

    分布式缓存(Redis)及消息队列(Kafka) 设想一种情况,服务A频繁的调用服务B的数据,但是服务B的数据更新的并不频繁. 实际上,这种情况并不少见,大多数情况,用户的操作更多的是查询.如果我们缓 ...

  5. 用过消息队列?Kafka?能否手写一个消息队列?懵

    是否有同样的经历?面试官问你做过啥项目,我一顿胡侃,项目利用到了消息队列,kafka,rocketMQ等等. 好的,那请开始你的表演,面试官递过一支笔:给我手写一个消息队列!!WHAT? 为了大家遇到 ...

  6. 【消息队列】kafka是如何保证消息不被重复消费的

    一.kafka自带的消费机制 kafka有个offset的概念,当每个消息被写进去后,都有一个offset,代表他的序号,然后consumer消费该数据之后,隔一段时间,会把自己消费过的消息的offs ...

  7. 【消息队列】kafka是如何保证高可用的

    一.kafka一个最基本的架构认识 由多个broker组成,每个broker就是一个节点:创建一个topic,这个topic可以划分为多个partition,每个partition可以存在于不同的br ...

  8. 消息队列之Kafka——从架构技术重新理解Kafka

    Apache Kafka® 是 一个分布式流处理平台. 这到底意味着什么呢? 我们知道流处理平台有以下三种特性: 可以让你发布和订阅流式的记录.这一方面与消息队列或者企业消息系统类似. 可以储存流式的 ...

  9. 01 . 消息队列之(Kafka+ZooKeeper)

    消息队列简介 什么是消息队列? 首先,我们来看看什么是消息队列,维基百科里的解释翻译过来如下: 队列提供了一种异步通信协议,这意味着消息的发送者和接受者不需要同时与消息保持联系,发送者发送的消息会存储 ...

随机推荐

  1. 洛谷 P3931 SAC E#1 - 一道难题 Tree

    题目背景 冴月麟和魏潇承是好朋友. 题目描述 冴月麟为了守护幻想乡,而制造了幻想乡的倒影,将真实的幻想乡封印了.任何人都无法进入真实的幻想乡了,但是她给前来救她的魏潇承留了一个线索. 她设置了一棵树( ...

  2. Ajax案例:异步加载后台订单详情信息

  3. Python集合的常用操作

    字典常用的就是,他的去重. set集合是python的一个基本数据类型. set中的元素是不重复的.⽆无序的.⾥面的元素必须是可hash的(int, str, tuple,bool). 我们可以这样来 ...

  4. 【BZOJ2428】均分数据

    题解 先说说黄学长的做法: 当温度比较高的时候,贪心 每次随机一个数,把他放进当前和最少的那一组里面 温度足够低的时候就完全随机然后转移 对于一个排列,分组强制连续 答案显然唯一,做一遍(dp)就好 ...

  5. 洛谷1220(区间dp)

    要点 处于什么位置的题常用一个套路就是搞完\([l,r]\)以后处于0(l)或1(r)的状态,即\(dp[i][j][0/1]\). 对于此题dp意义为已经搞完\([l,r]\)的时最小的已耗电能,转 ...

  6. 牛客小白月赛13 G(双向搜索)

    AC通道 两边同步搜,一步里面A走一次B走两次,遇到对方走过的地方就得到了答案. #include <bits/stdc++.h> using namespace std; const i ...

  7. NetCore1.1+Linux

    NetCore1.1+Linux部署初体验   1.环境准备 Centaos7+Win10 虚拟机 Win10安装VS2017 https://www.asp.net/downloads注意勾选下.N ...

  8. 爬虫(BeautifulSoup4)——安装

    环境:python3 win10 安装这个心好累啊!网上找了很多办法都安装不成功,后来换了几个安装包,最后4.4.1版本的包终于能用了! https://blog.csdn.net/www520507 ...

  9. D. Restructuring Company 并查集 + 维护一个区间技巧

    http://codeforces.com/contest/566/problem/D D. Restructuring Company time limit per test 2 seconds m ...

  10. Linux学习笔记——如何使用echo指令向文件写入内容

    0.前言     本文总结如何使用echo命令向文件中写入内容,例如使用echo指令覆盖文件内容,使用echo指令向文件追加内容,使用echo指令往文件中追加制表符.     echo向文件中输出内容 ...