2015年阿里研发工程师实习笔试附加题
题目1：
常常会有频繁申请、释放内存的需求，比如在发送网络报文时，每次都要分配内存以存储报文，等报文发送完成后又需要删除报文。
为了避免频繁的new/delete对系统带来的开销，需要实现一个通用的FreeList机制。使用者总是从free list中分配内存，如果存在没有使用的内存块就直接摘出来使用，如果没有的话再从系统中分配。使用完毕后并不去直接delete该内存块，而是交给FreeList保管。
要求：
- 实现一个对固定大小内存块进行管理的通用FreeList类，给出定义和实现。要求不能使用STL中的容器类。定义类的接口和实现时注意通用性、健壮性和可测试性。
- 如果该类的对象可能会被多个thread同时访问，请描述如何怎样保证线程安全。有没有办法在保证线程安全的同时尽可能增大并发度？如果有也请描述你的思路。
#include <bits/stdc++.h>
#include <Windows.h>
//#include <afxmt.h>
using namespace std;
const int N = 32;
template<typename T>
class MemoryPool {
public:
MemoryPool() { Expand(); };
MemoryPool(size_t cnt) {
Expand();
}
~MemoryPool() {
MemoryPool<T> *pNext = nullptr;
for (pNext = FreeList; pNext != nullptr;pNext=FreeList) {
FreeList = FreeList->FreeList;
delete[](char*)pNext;
}
}
void *Alloc() {
if (FreeList == nullptr)
Expand();
MemoryPool<T>* p = nullptr;
p = FreeList;
FreeList = FreeList->FreeList;
return p;
}
void Free(void *p){
MemoryPool<T> *tmp = nullptr;
tmp = static_cast<MemoryPool<T>*>(p);
tmp->FreeList = FreeList;
FreeList = tmp;
}
void Expand(int cnt = N) {
size_t size = max(sizeof(T) , sizeof(MemoryPool<T>*));
MemoryPool<T> *LastItem = static_cast<MemoryPool<T>*>(static_cast<void *>(new char[size]));
FreeList = LastItem;
for (int i = 0; i < cnt; i++) {
LastItem->FreeList = static_cast<MemoryPool<T>*>(static_cast<void *>(new char[size]));
LastItem = LastItem->FreeList;
}
LastItem->FreeList = nullptr;
}
MemoryPool<T> *FreeList;
};
class CriticalSection{
public:
CriticalSection() {
InitializeCriticalSection(&cs);
}
~CriticalSection() {
DeleteCriticalSection(&cs);
}
void Lock() {
EnterCriticalSection(&cs);
}
void Unlock() {
LeaveCriticalSection(&cs);
}
CRITICAL_SECTION cs;
};
template<typename T,typename L>
class MTMemoryPool {
public:
MTMemoryPool() {};
void *Alloc() {
void *p = nullptr;
lock.Lock();
p = pool.Alloc();
lock.Unlock();
return p;
}
void Free(void *p) {
lock.Lock();
pool.Free(p);
lock.Unlock();
}
T pool;
L lock;
};
class Node {
public:
static void *inew() {
void *p = s_pool->Alloc();
return p;
}
static void idelete(void *p) {
s_pool->Free(p);
}
static void NewPool() {
s_pool = new MTMemoryPool<MemoryPool<Node>, CriticalSection>;
}
static void DeletePool() {
delete s_pool;
s_pool = nullptr;
}
static MTMemoryPool<MemoryPool<Node>, CriticalSection> *s_pool;
};
MTMemoryPool<MemoryPool<Node>, CriticalSection> *Node::s_pool = nullptr;
void fun() {
Node *test[100005];
for (int i = 0; i <= 100000; i++) {
test[i] = new Node;
}
for (int i = 0; i <= 100000; i++) {
delete test[i];
}
}
void ifun() {
Node *test[100005];
for (int i = 0; i <= 100000; i++) {
test[i]=(Node*)Node::inew();
}
for (int i = 0; i <= 100000; i++) {
Node::idelete(test[i]);
}
}
int main() {
int start = clock();
fun();
printf("%d\n", clock() - start); //GetTickCount();
start = clock();
Node::NewPool();
ifun();
Node::DeletePool();
printf("%d\n", clock() - start);
return 0;
}
可能由于只用一个线程什么的，用了临界区等，反而时间慢了一倍。。。
题目2：
假设这样一个场景：当很多用户并发获取服务，server端资源不足时，希望用户能够按照预先分配的配额来使用资源。
比如预先定义好user1, user2, user3的配额是20%, 30%, 50%，资源争抢时希望服务器有20%的服务能力分配给user1， 30%给user2， 50%给user3。
但是如果某个时刻只有user1的请求，server还是要把100%的服务能力分配给user1以充分利用资源；又如某个时间段只有user2/user3在访问服务，则按照30%:50%的比率来分配资源。
需要通过一个类似于队列的ManagedQueue类来封装上述功能。
入队的时候需要提供user id（32位正整数）以及用户的任务(Task)。我们假设系统的用户数是有上限的，不会超过10个。
当队列中各个用户的请求均非空时，要求出队的task分布符合用户的配额设置。延续上面的例子如果连续出队100次，要求user1的task有20个左右，user2的task 30个左右， user3的50个左右。
这里出队的task恰好能对应服务器的服务能力。
要求：
- 给出关键数据结构以及ManagedQueue的定义。用户任务Task可以认为是一个已经实现的类来使用。可以使用STL容器类。
- 实现出队方法Dequeue()，请尽可能写健壮的代码
注意：这里并不要求精确的按照比例分配任务，只要统计意义上满足预定义的配额比例就可以了。
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
struct ManagedQueue {
int id;
int data;
};
deque<ManagedQueue> dq;
struct Node {
bool flag;
int cnt;
};
void fun(int x) {
}
void test(vector<int> v,int cnt) {
vector<ManagedQueue>g;
vector<Node>c;
while (!dq.empty()) {
c.clear(); g.clear();
for (int i = 0; i < v.size(); i++)
c.push_back(Node{ 0,0 });
for (int i = 0; i < cnt; i++) {
g.push_back(dq.front());
c[dq.front().id].flag = true;
dq.pop_front();
}
int total = 0;
for (int i = 0; i < v.size(); i++) {
if (c[i].flag) {
total += v[i];
}
}
for (int i = 0; i < v.size(); i++) {
if (c[i].flag) {
c[i].cnt = max(1,cnt*v[i] / total);
}
}
for (int i = 0; i < cnt; i++) {
if (c[g[i].id].cnt > 0) {
fun(g[i].data);
c[g[i].id].cnt--;
}
else {
dq.push_front(g[i]);
}
}
}
}
int main() {
//init dq;
vector<int> v = { 2,3,5 };
int cnt=100;
test(v,cnt);
return 0;
}
题目3：
分布式系统中的RPC请求经常出现乱序的情况。
写一个算法来将一个乱序的序列保序输出。例如,假设起始序号是1，对于(1, 2, 5, 8, 10, 4, 3, 6, 9, 7)这个序列，输出是:
1
2
3, 4, 5
6
7, 8, 9, 10
上述例子中，3到来的时候会发现4,5已经在了。因此将已经满足顺序的整个序列（3, 4, 5）输出为一行。
要求：
- 写一个高效的算法完成上述功能，实现要尽可能的健壮、易于维护
- 为该算法设计并实现单元测试
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
int a[N];
int vis[N];
int main() {
int n; cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int j = 1;
for (int i = 1; i <= n; i++) {
vis[a[i]] = 1;
if (a[i] == j) {
while (vis[j]) {
printf("%d ", j);
j++;
}
printf("\n");
}
}
return 0;
}
不知道对不
