探究一种定长队列操作（C ,C++版本）

最新推荐文章于 2024-05-03 23:11:57 发布
最新推荐文章于 2024-05-03 23:11:57 发布
阅读量3k 收藏
点赞数
分类专栏： Linux C++算法系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangzhicheng1983/article/details/41125537
版权

一 问题来源：南京烽火通信面试

二 问题：

现有一种定长队列，长度为2的n次方，此队列可被多线程访问，但必须确保线程级安全，即在任意时刻，队列的长度保持不变。

三 笔者分析

1. 队列的存储结构--链式和顺序均可。

2. 长度为2的n次方--便于移动队头和队尾指针，假设队列长度为size，那么rear = (rear + 1) & (size - 1)，&运算比算术求模运算效率高。为此，笔者使用了顺序队列。

3. 怎么确保线程级安全

笔者认为此系统一定同时存在多个读者和写者，读者是读取队头元素，写者是不断向队尾插入元素，读者与读者之间，读者与写者之间，写者与写者之间都必须互斥访问，因此，必须采用互斥锁，保证任意时刻队列长度不变。为此，笔者定义一个全局变量balance。

读者 get

加锁

检测balance为1吗？如果为1，表明队尾已经有一个元素加入， 那么读取队头，并将balance = 0

解锁

写者 put

加锁

检测balance为0吗？如果为0，表明队列平衡，没有元素插入， 那么在队列插入元素，并将balance = 1

解锁

这样能够确保同一时刻读、写者之间彼此是互斥的。

四 代码组织


五 代码详解

1. queue.h

/*************************************************************************
    > File Name: queue.h
    > Author: wangzhicheng
    > Mail: 2363702560@qq.com 
    > Created Time: Fri 14 Nov 2014 11:23:55 AM WST
 ************************************************************************/
#ifndef _QUEUE_H_
#define _QUEUE_H_
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#define MAX 1024    // the max storage space
typedef int DataType;   // data type
/*
 * sequenece queue
 * */
typedef struct Queue {
	DataType *array;
	int front;       // pointer to the header node of queue
	int rear;        // pointer to the next position of last node in the queue
	int size;        // initial size of the queue size should be 8 bytes
}Queue;
Queue Q;
int balance;   // should be 0, 1 -- a node add in the queue
pthread_mutex_t mutex;  // mutex lock
int InitQueue();
int reInitQueue(uint);
int get(DataType *);
int put(DataType);
#endif

2. queue.c 

/*************************************************************************
    > File Name: queue.c
    > Author: wangzhicheng2013
    > Mail: 2363702560@qq.com 
    > Created Time: Fri 14 Nov 2014 03:01:32 PM WST
 ************************************************************************/
#include "queue.h"
/*
 * initialize the queue
 * return 0 if successfully 
 * else return -1
 * */
int InitQueue() {
	int rc = 0;
	int i;
	Q.array = (DataType *)malloc(sizeof(DataType) * MAX);
	if(!Q.array) {
		rc = -1;
		printf("Init Queue failed, Memeory lack...!\n");
	}
	else {  // initialize the queue
		Q.front = 0;
		Q.size = 8;
		Q.rear = Q.size;
		for(i = 0;i < Q.size;i++) Q.array[i] = i;  
		pthread_mutex_init(&mutex, NULL);
	}

	return rc;
}
/*
 * reinitialize the queue
 * return 0 if successfully 
 * else return -1
 * */
int reInitQueue(uint capacity) {
	int rc = 0;
	int i;
	if(capacity >= MAX) rc = -1;
	else {  // initialize the queue
		for(i = 2;i < capacity;i = i << 1) ;
		if(i > capacity) i = i / 2;  // compute the max 2 ^ n less than capacity
		Q.size = i;
		for(i = Q.rear;i < Q.size;i++) Q.array[i] = i;  
		Q.rear = Q.size;
	}

	return rc;
}
/*
 * get a element from the queue
 * return 0 if successfully 
 * else return -1
 * */
int get(DataType *e) {
	int rc = -1;
	pthread_mutex_lock(&mutex);
	if(balance) {   // if put a node in the queue before
		*e = Q.array[Q.front];
		Q.front = (Q.front + 1) & (Q.size - 1);  // circularly move, save much time
		balance = 0; // return orgin
		rc = 0;
	}
	pthread_mutex_unlock(&mutex);

	return rc;
}
/*
 * put a element in the queue
 * return 0 if successfully 
 * else return -1
 * */
int put(DataType e) {
	int rc = -1;
	pthread_mutex_lock(&mutex);
	if(!balance) {   // if the queue is balanced
		Q.array[Q.rear] = e;
		Q.rear = (Q.rear + 1) & (Q.size - 1);  // circularly move, save much time
		balance = 1;
		rc = 0;
	}
	pthread_mutex_unlock(&mutex);

	return rc;
}

3. main.c 

/*************************************************************************
    > File Name: main.c
    > Author: ma6174
    > Mail: ma6174@163.com 
    > Created Time: Fri 14 Nov 2014 03:26:48 PM WST
 ************************************************************************/

#include "queue.h"
#include <time.h>
#define THREAD_NUM 20
void *_read(void *arg) {
	DataType e;
	while(1) {
		if(get(&e)) {
			perror("read failed...!\n");
		}
		else printf("%d has been read...!\n", e);
		usleep(20);
//		sleep(1);
	}
}
void *_write(void *arg) {
	DataType e = rand() % 10;
	while(1) {
		if(put(e)) {
			perror("write failed...!\n");
		}
		else printf("%d has been write...!\n", e);
		usleep(20);
//		sleep(1);
	}
}
int main() {
	if(InitQueue()) {
		exit(EXIT_FAILURE);
	}
	srand((unsigned)time(NULL));
	pthread_t threads[THREAD_NUM];
	int i;
	for(i = 0;i < THREAD_NUM;i++) {
		if(i < THREAD_NUM / 2) {
			if(pthread_create(&threads[i], NULL, _read, NULL)) {
				perror("thread created failed...!\n");
			}
		}
		else {
			if(pthread_create(&threads[i], NULL, _write, NULL)) {
				perror("thread created failed...!\n");
			}
		}
	}
	for(i = 0;i < THREAD_NUM;i++) {
		pthread_join(threads[i], NULL);
	}

	return 0;
}


4. Makefile 

CC=gcc
all:
	$(CC) -g -o main src/main.c src/queue.c header/queue.h -I src/ -I header/ -lpthread

六 运行测试


C++版本

一  代码组织与以上相似，将接口与实现分离

二 代码详解

1. queue.h

/*************************************************************************
    > File Name: queue.h
    > Author: ma6174
    > Mail: ma6174@163.com 
    > Created Time: Sat 15 Nov 2014 10:30:21 AM WST
 ************************************************************************/
#ifndef _QUEUE_H_
#define _QUEUE_H_
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <iostream>
#include <queue>
#define MAX 1024
using namespace std;
template<class DataType>
class Queue {
	private:
		queue<DataType>Q;   // the STL quque
		uint size;			// the size of queue
		uint balance;		
		pthread_mutex_t mutex;
	public:
		Queue();
		bool get(DataType &);
		bool put(DataType);
};
#include "queue.cpp"
#endif

2. queue.cpp 

/*************************************************************************
    > File Name: queue.h
    > Author: ma6174
    > Mail: ma6174@163.com 
    > Created Time: Sat 15 Nov 2014 10:30:21 AM WST
 ************************************************************************/
#ifndef QUEUE_CPP
#define QUEUE_CPP	
#include "queue.h"
template<class DataType>
Queue<DataType>::Queue() {
	this->size = 8;
	this->balance = 0;
	pthread_mutex_init(&this->mutex, NULL);
	int i;
	for(i = 0;i < this->size;i++) this->Q.push(i);
}
template<class DataType>
bool Queue<DataType>::get(DataType &e) {
	bool rc = false;
	pthread_mutex_lock(&this->mutex);
	if(this->balance) {
		e = this->Q.front();
		this->Q.pop();
		this->balance = 0;
		rc = true;
	}
	pthread_mutex_unlock(&this->mutex);

	return rc;
}
template<class DataType>
bool Queue<DataType>::put(DataType e) {
	bool rc = false;
	pthread_mutex_lock(&this->mutex);
	if(!this->balance) {
		this->Q.push(e);
		this->balance = 1;
		rc = true;
	}
	pthread_mutex_unlock(&this->mutex);

	return rc;
}
#endif

3. main.cpp 

/*************************************************************************
    > File Name: main.cpp
    > Author: ma6174
    > Mail: ma6174@163.com 
    > Created Time: Sat 15 Nov 2014 10:52:49 AM WST
 ************************************************************************/

#include "queue.h"
#define THREAD_NUM 10
using namespace std;
typedef int DataType;
Queue<DataType>q;
void *_read(void *arg) {  
    DataType e;  
    while(1) {  
        if(q.get(e) == false) {  
            perror("read failed...!\n");  
        }  
        else printf("%d has been read...!\n", e);  
	    usleep(20);  
//	    sleep(1);  
    }  
}  
void *_write(void *arg) {  
    DataType e = rand() % 10;  
    while(1) {  
        if(q.put(e) == false) {  
            perror("write failed...!\n");  
        }  
        else printf("%d has been write...!\n", e);  
	    usleep(20);  
//	    sleep(1);  
    }  
}
int main() {
    srand((unsigned)time(NULL));  
    pthread_t threads[THREAD_NUM];  
    int i;  
    for(i = 0;i < THREAD_NUM;i++) {  
        if(i < THREAD_NUM / 2) {  
            if(pthread_create(&threads[i], NULL, _read, NULL)) {  
                perror("thread created failed...!\n");  
            }  
        }  
        else {  
            if(pthread_create(&threads[i], NULL, _write, NULL)) {  
                perror("thread created failed...!\n");  
            }  
        }  
    }  
    for(i = 0;i < THREAD_NUM;i++) {  
        pthread_join(threads[i], NULL);  
    }  
  
	return 0;
}

4. Makefile 

CC=g++
all:
#	$(CC) -g -o main src/main.c $/src/queue.c $/header/queue.h -lpthread
	$(CC) -g -o main src/main.cpp src/queue.cpp header/queue.h -I src/ -I header/ -lpthread

三 测试


无锁实现

1. cas.h

/*************************************************************************
    > File Name: cas.h
    > Author: ma6174
    > Mail: ma6174@163.com 
    > Created Time: Wed 26 Nov 2014 09:11:28 PM WST
 ************************************************************************/

#ifndef _CAS_H_
#define _CAS_H_
int cas(int *reg, int oldval, int newval) {
	if(*reg == oldval) {
		*reg = newval;
		return 1;
	}
	return 0;
}
#endif

2. queue.h 

/*************************************************************************
    > File Name: queue.h
    > Author: wangzhicheng
    > Mail: 2363702560@qq.com 
    > Created Time: Fri 14 Nov 2014 11:23:55 AM WST
 ************************************************************************/
#ifndef _QUEUE_H_
#define _QUEUE_H_
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#define MAX 1024    // the max storage space
enum {
	Empty, Full
};
typedef struct node {
	int elem;
	int status;  // Empty or Full
}node;
/*
 * sequenece queue
 * */
typedef struct Queue {
	node *array;
	int front;       // pointer to the header node of queue
	int rear;        // pointer to the next position of last node in the queue
	int size;        // the size of the queue
}Queue;
Queue Q;
int InitQueue();
int get(int *);
int put(int);
#endif

3. queue.c

/*************************************************************************
    > File Name: queue.c
    > Author: wangzhicheng2013
    > Mail: 2363702560@qq.com 
    > Created Time: Fri 14 Nov 2014 03:01:32 PM WST
 ************************************************************************/
#include "queue.h"
#include "cas.h"
/*
 * initialize the queue
 * return 0 if successfully 
 * else return -1
 * */
int InitQueue() {
	int rc = 0;
	int i;
	Q.array = (node *)malloc(sizeof(node) * MAX);
	if(!Q.array) {
		rc = -1;
		printf("Init Queue failed, Memeory lack...!\n");
	}
	else {  // initialize the queue
		for(i = 0;i < MAX;i++) Q.array[i].status = Empty;
		Q.front = 0;
		Q.rear = 8;
		Q.size = 8;
		for(i = 0;i < Q.size;i++) {
			Q.array[i].status = Full;
			Q.array[i].elem = i;
		}
	}

	return rc;
}
/*
 * putt a element in the queue
 * return 0 if successfully 
 * else return -1
 * */
int put(int e) {
	int rc = 0;
	do {
		if((Q.rear + 1) & (Q.size - 1) == Q.front) {
			perror("Now queue is full...!\n ");
			rc = -1;
			goto quit;
		}
	}while(!cas(&Q.array[Q.rear].status, Empty, Full));
	Q.array[Q.rear].elem = e;
	cas(&Q.rear, Q.rear, (Q.rear + 1) & (Q.size - 1));
quit:
	return rc;
}
/*
 * gett a element from the queue
 * return 0 if successfully 
 * else return -1
 * */
int get(int *e) {
	int rc = 0;
	do {
		if(Q.front == Q.rear) {
			perror("Now queue is empty...!\n ");
			rc = -1;
			goto quit;
		}
	}while(!cas(&Q.array[Q.front].status, Full, Empty));
quit:
	*e = Q.array[Q.front].elem;
	cas(&Q.front, Q.front, (Q.front + 1) & (Q.size - 1));
	return rc;
}

4. main.c 

/*************************************************************************
    > File Name: main.c
    > Author: ma6174
    > Mail: ma6174@163.com 
    > Created Time: Fri 14 Nov 2014 03:26:48 PM WST
 ************************************************************************/

#include "queue.h"
#include <time.h>
#define THREAD_NUM 20
void *_read(void *arg) {
	int e;
	while(1) {
		if(get(&e)) {
			perror("read failed...!\n");
		}
		else printf("%d has been read...!\n", e);
		usleep(20);
//		sleep(1);
	}
}
void *_write(void *arg) {
	int e = rand() % 10;
	while(1) {
		if(put(e)) {
			perror("write failed...!\n");
		}
		else printf("%d has been write...!\n", e);
		usleep(20);
//		sleep(1);
	}
}
int main() {
	if(InitQueue()) {
		exit(EXIT_FAILURE);
	}
	srand((unsigned)time(NULL));
	pthread_t threads[THREAD_NUM];
	int i;
	for(i = 0;i < THREAD_NUM;i++) {
		if(i < THREAD_NUM / 2) {
			if(pthread_create(&threads[i], NULL, _read, NULL)) {
				perror("thread created failed...!\n");
			}
		}
		else {
			if(pthread_create(&threads[i], NULL, _write, NULL)) {
				perror("thread created failed...!\n");
			}
		}
	}
	for(i = 0;i < THREAD_NUM;i++) {
		pthread_join(threads[i], NULL);
	}

	return 0;
}

5.Makefile 

CC=gcc
all:
#	$(CC) -g -o main src/main.c $/src/queue.c $/header/queue.h -lpthread
	$(CC) -g -o main src/main.c src/queue.c header/queue.h header/cas.h -I src/ -I header/ -lpthread

运行


I am 006!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ STL--queue队列容器学习笔记
小熊的专栏
01-02 3299
queue队列也是一个线性存储表，与后进先出的堆栈不同，元素数据在表的一端插入，在另一端进行删除，即构成了先进先出FIFO表。插入的一端成为队尾，删除的一端成为队首。     由于C++ STL的队列泛化，默认使用的是双端队列deque来实现。     实际上，我们使用的是queue队列是否为空，取队首元素，取队尾元素，元素入队和元素出队等功能。     queue队列应用     创建q
C++用数组实现一个固定大小的栈/队列
爱她就要努力
08-21 558
https://blog.csdn.net/u014228447/article/details/80709655 #include<iostream>#include<exception>using namespace std;#define NUM 5//用数组结构实现大小固定的队列和栈class Array
C语言用数组（顺序表）实现大小固定的队列的方法
Dontla的博客
03-17 580
顺序队列，即采用顺序表模拟实现的队列结构。 我们知道，队列具有以下两个特点： 1、数据从队列的一端进，另一端出； 2、数据的入队和出队遵循"先进先出"的原则； 因此，只要使用顺序表按以上两个要求操作数据，即可实现顺序队列。首先来学习一种最简单的实现方法。 顺序队列简单实现 由于顺序队列的底层使用的是数组，因此需预先申请一块足够大的内存空间初始化顺序队列。除此之外，为了满足顺序队列中数据从队尾进，队头出且先进先出的要求，我们还需要定义两个指针（top 和 rear）分别用于指向顺序队列中的队头元素和队尾元素，
C++ 自定义循环数组（定长队列）
最新发布
05-03 18
使用数组实现定长队列，可用于静态均线MA或动态均线MA
C++用数组结构实现大小固定的队列
暮日落流年的博客
05-05 3010
1. 思路 队列的先进先出的，需要一个数组和4个变量size,end,start,length。size记录已经进来了多少个元素，end记录刚进来的元素应该放在哪个位置，start表示用户要求弹出的元素所在的位置。size的作用不止于此，它还是end与start的操作的关键信息，使得end与start解耦，避免的很多的麻烦，当end或者start到底部的时候就跳回0处。length是数组的长度，...
用C++进行队列的设置——两种
qq_51293136的博客
12-01 898
在学习队列时的一些操作方法的记录
C++利用链表模板类实现简易队列
08-26
本文主要为大家详细介绍了C++利用链表模板类实现一个简易队列，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 知识点一：链表模板类 在C++中，链表是一种常用的数据结构，链表模板类是指使用模板类来实现...
基于一个简单定长内存池的实现方法详解
09-05
内存池是一种内存管理技术，它预先分配一大块内存并将其分割成多个固定大小的小块，称为内存块或chunk。这种技术常用于优化内存分配和回收，特别是在多线程环境中，可以减少频繁的内存申请和释放导致的开销。本文将...
易语言核心支持库编写高效率定长队列
05-27
采用核心支持库基础代码编写，稳定高效，代码简洁明了，方便维护和升级，百万次压入弹出耗时94毫秒。...在之前的版本上的一次升级，命令按照核心支持库中的“队列”进行了效仿，效率是核心支持库的N倍！。@糖心疼。
在编程语言中怎样定义队列及其使用(C++)
12-31
队列在编程语言中是如何定义的呢？小编与大家分享自己的经验。 队列的定义 队列是限制结点插入操作固定在一端进行,而结点的删除操作固定在另一端进行的线性表. 队列犹如一个两端开口的...队列是一种先进先出（First
信息论，定长编码源码，C++，信号处理
01-19
C++是一种面向对象的编程语言，由Bjarne Stroustrup在C语言的基础上发展而来。C++支持泛型编程、模板、类、异常处理、内存管理等高级特性，广泛应用于系统软件、应用软件、游戏开发、驱动程序等领域。在这个示例中，...
C++ Queue（带上限的）
11-06
C++ Queue（带上限的） 上限可以改，做小题可以
collection.deque 固定长度队列
weixin_37804469的博客
04-09 1124
collection.deque deque (maxlen=N)创建了一个固定长度的队列，最大长度为N, 可添加元素 ： q.append() 可弹出元素 ： q.pop() 默认从右边添加和弹出，也可从左边添加和弹出元素： q.appendleft()， q.popleft() from collections import deque q = deque(maxlen=3) q.appen...
【STL之queue】队列的使用
恒治学
11-25 193
【STL之queue】队列的使用 操作集 q.front(); q.back(); q.push(x); q.pop(); q.size(); q.empty(); 代码 #include <iostream> #include <queue> using namespace std; queue<int> q; int main(){ for (in...
容器适配器之queue用法总结
陈实Yepper
12-23 1097
只能访问 queue 容器适配器的第一个和最后一个元素。只能在容器的末尾添加新元素，只能从头部移除元素。 许多程序都使用了 queue 容器。queue 容器可以用来表示超市的结账队列或服务器上等待执行的数据库事务队列。对于任何需要用 FIFO 准则处理的序列来说，使用 queue 容器适配器都是好的选择。 图 1 展示了一个 queue 容器及其一些基本操作： queue 的生成方式和 sta...
c++队列
m0_72125469的博客
08-02 2987
队列：队列也是操作受限的线性表 限定在只能在表的一端进行插入 在表的另一端进行删除 c++队列 队列的基本操作c++ 数据结构c++队列
STL中队列QUEUE中元素改变大小（resize)可能出现的问题！
kaithelen的专栏
11-07 1589
待续……
LimitQueue固定长度的队列
热门推荐
阿飞的博客
06-03 1万+
在开发过程中，有时会有这样的需求，一个固定长度的集合里，当收到新的数据时自动丢掉最旧的数据这样的队列结构。其实实现并不难，即一个队列结构的集合，在推送新数据时判断一下，当集合大小已经达到限制长度时自动丢掉最旧的数据。import java.util.LinkedList; public class LimitQueue&lt;E&gt;{ private int limit; //...
固定尺寸内存块的缓冲队列类及C++实现源码
Kyee编程之道
10-22 2881
本文讲的缓冲队列为链接方式, 链接方式一般通过预分配一个结点作为接力点来实现无锁队列, 优点是实现简单, 缺点是浪费一个结点的内存, 当结点内存块尺寸较大时浪费就大了。如何不浪费一个结点内存的链接方式无锁队列? 当队列中只有一个结点时, 本缓冲队列中使用了原子锁进行操作, 这是一种平衡策略, 若读者有更好方法不妨告之一下!
定长 fifo 队列 java
06-03
在 Java 中，可以使用数组来实现定长 FIFO 队列。以下是一个示例代码： ```java public class FixedFifoQueue<T> { private T[] queue; private int head; private int tail; private int size; public FixedFifoQueue(int capacity) { this.queue = (T[]) new Object[capacity]; this.head = 0; this.tail = 0; this.size = 0; } public void enqueue(T item) { if (size == queue.length) { throw new IllegalStateException("Queue is full"); } queue[tail] = item; tail = (tail + 1) % queue.length; size++; } public T dequeue() { if (size == 0) { throw new IllegalStateException("Queue is empty"); } T item = queue[head]; queue[head] = null; head = (head + 1) % queue.length; size--; return item; } public boolean isEmpty() { return size == 0; } public boolean isFull() { return size == queue.length; } public int size() { return size; } } ``` 在这个队列中，enqueue() 方法用于将元素添加到队列尾部，dequeue() 方法用于从队列头部移除元素并返回它。如果队列已满，将会抛出一个 IllegalStateException 异常；如果队列为空，将会抛出同样的异常。isEmpty() 方法用于判断队列是否为空，isFull() 方法用于判断队列是否已满，size() 方法用于获取队列中元素的数量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值