Jepson's Blog
0%

Posted on Edited on

启动zokeeper

进入zokeeper的bin目录

1
cd /usr/local/zookeeper/apache-zookeeper-3.8.0-bin/bin/

开启zookeeper集群

1
./zkCli.sh -server 192.168.79.128:2181,192.168.79.128:2182,192.168.79.128:2183,192.168.79.128:2184

启动kafka服务器

进入kafka的bin目录

1
cd /usr/local/kafka/kafka_2.11-2.4.1/bin/

启动kafka

1
./kafka-server-start.sh -daemon ../config/server.properties

检查是否启动成功

1
ps -aux|grep server.properties

创建topic

通过kafka命令创建一个topic

1
./kafka-topics.sh --create --zookeeper 192.168.79.128:2181 --replication-factor 1 --partitions 1 --topic test

查看zk中所有topic

1
./kafka-topics.sh --list --zookeeper 192.168.79.128:2181

发送消息

生产者发送消息

1
./kafka-console-producer.sh --broker-list 192.168.79.129:9092 --topic test

接收消息

消费者接收消息

  • 方式一：从最后一条消息的偏移量+1开始消费
1
./kafka-console-consumer.sh --bootstrap-server 192.168.79.129:9092 --topic test
  • 方式二：从头开始消费
1
./kafka-console-consumer.sh --bootstrap-server 192.168.79.129:9092 --from-beginning --topic test

单播消息

两个消费者在同一个组

1
./kafka-console-consumer.sh --bootstrap-server 192.168.79.129:9092 --consumer-property group.id=testGroup --topic test

如果多个消费者在同一个消费者组，那么只有一个消费者能收到订阅的topic中的消息

多播消息

两个消费者在不同组

1
./kafka-console-consumer.sh --bootstrap-server 192.168.79.129:9092 --consumer-property group.id=testGroup --topic test
1
./kafka-console-consumer.sh --bootstrap-server 192.168.79.129:9092 --consumer-property group.id=testGroup1 --topic test

可以同时收到消息

查看消费者组

查看有哪些消费者组

1
./kafka-consumer-groups.sh --bootstrap-server 192.168.79.129:9092--topic test

查看某个组的具体信息

1
./kafka-consumer-groups.sh --bootstrap-server 192.168.79.129:9092 --describe --group testGroup

topic和patition

topic

kafka中的topic是一个逻辑概念，通过topic对消息进行分类，不同的topic会被订阅该topic的消费者消费。

如果消息非常多，因为消息是会被保存在log日志中，为了解决文件过大的问题，kafka提出了patition的概念。

partition

通过partition将topic的消息分区存储

  • 解决了log文件过大的问题

  • 提高生产者和消费者的吞吐量，读和写可以在多个分区同时进行

创建多分区topic

1
./kafka-topics.sh --create --zookeeper 192.168.79.128:2181 --replication-factor 1 --partitions 2 --topic test1

搭建kafka集群

1
2
3
./kafka-server-start.sh -daemon ../config/server.properties
./kafka-server-start.sh -daemon ../config/server1.properties
./kafka-server-start.sh -daemon ../config/server2.properties

副本

一个主题，两个分区，三个副本

1
./kafka-topics.sh --create --zookeeper 192.168.79.128:2181 --replication-factor 3 --partitions 2 --topic my-replicated-topic

查看topic

1
./kafka-topics.sh --describe --zookeeper 192.168.79.128:2181 --topic my-replicated-topicmy-replicated-topic

20220322152036

副本时为分区建立的副本，一个leader其余是follower

读和写都发生在leader上，leader挂了从follower中选举产生新leader

follower接收leader的同步数据

20220322153205

集群发消息

1
./kafka-console-producer.sh --broker-list 192.168.79.129:9092,192.168.79.129:9093,192.168.79.129:9094 --topic my-replicated-topic

集群收消息

1
./kafka-console-consumer.sh --bootstrap-server 192.168.79.129:9092,192.168.79.129:9093,192.168.79.129:9094 --from-beginning --topic my-replicated-topic

分区分消费组的集群消费

20220322160204

一个partition最多被一个consumer消费（保证消费的顺序），一个consumer可以消费多个partition。

消费者组中consumer的数量不能比patition的数量多，不然多出来的consumer没有patition消费。

Posted on Edited on

VMware虚拟机

https://www.vmware.com/cn/products/workstation-pro/workstation-pro-evaluation.html

FinalShell SSH工具

http://www.hostbuf.com/t/988.html

ubuntu16.04

http://mirrors.zju.edu.cn/ubuntu-releases/16.04/

zookeeper

https://dlcdn.apache.org/zookeeper/zookeeper-3.8.0/apache-zookeeper-3.8.0-bin.tar.gz

分布式协调服务

用来实现分布式锁和无状态化

zookeeper可以保存数据但是不能当成数据库来使用，它主要是保存一些状态信息

ubuntu开启ssh

  1. 查看是否开启了ssh服务是否安装

    1
    sudo ps -e |grep ssh

  2. 先更新资源列表

    1
    sudo apt-get update

  3. 安装openssh-server

    1
    sudo apt-get install openssh-server

  4. 查看主机的IP地址

    1
    ifconfig

文件传输

  1. 安装lrzsz

    1
    apt-get install lrzsz

  2. 上传文件

    1
    rz

  3. 下载文件

    1
    sz

解压缩

1
tar -zxvf “文件名”

配置java环境

  1. 安装jre

    1
    apt-get install java openjdk-8-jre-headless

  2. 安装jdk

    1
    apt-get install java openjdk-8-jdk-headless

Posted on Edited on

已挂

  • 先简单介绍了一下部门工作
  • 问之前的面试感觉有什么不足或者经验总结
  • 问了个很专业性的问题，一开始都没怎么听懂。。
    • 大概是游戏场景里有多个agent，agent之间互相有交互，计算量太大服务器处理不过来，有什么优化办法
    • 感觉答的不怎么样。。主要这个问题太专业了，而且一看就是实际开发中遇到的问题，我完全没接触过。。
    • 不过面试官还挺好的，一直在介绍，以及互相沟通，有种同事间共同解决问题的感觉
  • 竟然真的读了简历上的个人总结，因为我上面写着善于发现问题、解决问题，面试官就问了怎么善于发现问题，解决问题。。
  • 还问了生活中碰到困难怎么解决
  • 遇到过什么挑战和挫折，怎么解决
  • 科研项目里的PCA
  • 翻到19年的面试记录，我都忘了本科时还面过腾讯。。上面写着网络编程方面有待提高，所以问了后面有没有去提高这方面
    • 回答了后面做过一个小的聊天室，能实现多人在聊天室里聊天，用的是socket通讯
    • tcp有什么用
    • 如果1号包到达了，2号包丢了，3号包到达了会怎么样，答了会缓存3号包请求重传2号包。。
    • 如果极端情况下3号包后面还有很多包也到达了会怎么样
  • c/c++问题
    • 虚函数有什么用
    • 在析构函数中调用虚函数要注意什么问题
  • map和unorder_map的区别，在什么情况下用什么
    • 只有100个数据，但是有大量的查询，用哪一个
  • 反问
    • 觉得自己要挂了，就问了下面试流程
    • 面试官说你都不问一下我们部门是干什么的么，瞬间尬住。。
    • 然后面试官仔细介绍了一下部门工作
    • 问了编程语言
    • 问了腾讯锁hc的事儿
  • 问了对工作地上海介意吗

不懂，感觉前面问题问的都好奇怪，答的也不怎么样，聊了不到一个小时，中间有点儿尬，感觉要挂。

总结一下以后反问环节可以问的问题：

  • 部门是干啥的，实习生去了干啥
  • 面试流程
  • 工作地点

Posted on

已挂

  • 技术终面
  • 一共大概30分钟，先一两分钟自我介绍一下
  • 科研项目
    • 对MPUTT？协议有什么了解
  • ACM竞赛负责的角色
  • 华为实习
    • 有什么成就
  • 场景题
    • 城市中点和点之间的最短路径，答了dijkstra
    • 假如是送快递或者送外卖，有多个目的地该怎么做，答了贪心，面试官说可能不是最优的
    • 路上的其它因素，比如堵车啊下一个目的地啊之类的怎么归一化
  • 哪个基础知识掌握的最好
    • 问了内存分配方面的支持
    • 怎么根据指针来计算空间大小
  • c/c++问题
    • 数组a[10]，这个方括号是啥，是宏定义、运算符、函数还是关键字，猜了个运算符
    • 具体细节
  • 对于开源软件的了解，读过源码吗
  • 以后的方向，有接触过这些方向的产品吗，打算什么时候接触
  • 还有什么想说的
  • 反问环节
    • 问了面试流程
    • 忘记问机试最后一题到底过没过了。。

应该挂了，感觉面试官对我兴趣不大，一直在找项目和实习方面的难点和亮点，感觉没找到。

Posted on

shared_ptr

多个shared_pt智能指针可以使用同一块堆内存，并且该类型只能指针在实现上采用的是引用计数机制。

即使有一个shared_ptr放弃了堆内存的使用权 （引用计数减1） 也不会影响其他shared_ptr的使用 只有引用计数为0 堆内存才会释放。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
template<class T>
class my_shared_ptr
{
private:
    int* _count;
    T* _ptr;
public:

    my_shared_ptr(T* ptr=nullptr){ // 构造函数，默认参数
        _ptr = ptr;
        _count = nullptr;

        if(_ptr){
            _count = new int(1);
        }
    }

    ~my_shared_ptr(){ // 析构函数
        if(_ptr&& --(*_count)==0){
            delete _ptr;
        }
    }

    my_shared_ptr(const my_shared_ptr<T>& a){ // 拷贝构造函数
        _ptr = a._ptr;
        _count = a._count;
        if(_ptr){
            (*_count) ++;
        }
    }

    my_shared_ptr<T>& operator=(const my_shared_ptr<T>& a){ // 赋值运算符
        if(this != &a){
            if(_ptr && --(*_count)==0){
                delete _ptr;
            }

            _ptr = a._ptr;
            _count = a._count;

            if(_ptr){
                (*_count) ++;
            }
        }
    }

    int getCount(){
        return *_count;
    }
};

weak_ptr

c++11虽然将weak_ptr指针定为智能指针的一种，但是该类型指针通常不单独使用（没有实际用处）

只能和share_ptr类型指针搭配使用，甚至我们将weak_ptr视为shared_ptr的一个辅助工具

借助weak_ptr指针我们可以获得shared_ptr指针的一些状态信息

比如有多少指向相同的shared_ptr指针，share_ptr指针指向的堆内存是否释放等等

unique_ptr

unique_ptr也具备“在适当的时机自动释放堆内内存空间”的能力

和shared_ptr最大的不同之处就是在于 unique_ptr指针指向的堆内存无法将其与其他unique_str共享

也就是说unique_ptr指针都独自拥有对其所指堆内存空间的所有权

这也就是说 每个unique_str指针指向的堆内存空间的引用计数就是只能为1

一旦该unique_ptr指针放弃所致堆内存空间的所有权，该空间会被立即释放回收

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template<class T>
class my_unique_ptr
{
private:
    T* _ptr;
public:
    my_unique_ptr(T* ptr=nullptr){
        _ptr = ptr;
    };
    ~my_unique_ptr(){
        if(_ptr){
            delete _ptr;
            _ptr = nullptr;
        }
    };
    my_unique_ptr(const my_unique_ptr<T> &a) = delete;
    my_unique_ptr<T>& operator=(const my_unique_ptr<T> &a) = delete;
};