C++ queue_get函数代码示例

void *main_thread(void *arg) {
	CircularQueue *entryQueue = create_all_numbers_queue(_max_number);
	
	CircularQueue *exitQueue;
	queue_init(&exitQueue, _max_number);
	
	pthread_t filter_tid;
	
	pthread_create(&filter_tid, NULL, filter_thread, exitQueue);
	
	unsigned int first = queue_get(entryQueue);
	
	if (place_number_into_shared_memory(first)) {
		printf("Error while accessing the shared memory region.\n");
		
		exit(EXIT_FAILURE);
	}
	
	#if DEBUG
	printf("Placed %d on the shared memory region.\n", first);
	#endif
	
	unsigned int number = 0;
	
	while (( number = queue_get(entryQueue) ))	//	Get each number from the entry queue up until "0"
		if (number % first)	//	Up so far, the number is not prime.
			queue_put(exitQueue, number);
	
	queue_put(exitQueue, 0);
	
	queue_destroy(entryQueue);
	
	return NULL;
}

void unsorted_mode() {
	queue_t *q = queue_create();
	
	char *t1 = malloc(1);
	char *t2 = malloc(2);
	char *t3 = malloc(4);
	char *t4 = malloc(8);
	
	test *s1 = malloc(sizeof(test));
	s1->test = t1; 
	test *s2 = malloc(sizeof(test));
	s2->test = t2; 
	test *s3 = malloc(sizeof(test));
	s3->test = t3; 
	test *s4 = malloc(sizeof(test));
	s4->test = t4; 
	
	queue_put(q, s1);
	queue_put(q, s2);
	queue_put(q, s3);
	queue_put(q, s4);
	
	test *t;
	queue_get(q, (void **)&t);
	free_test(t);
	queue_get(q, (void **)&t);
	free_test(t);
	
	queue_destroy_complete(q, (void *)free_test);
}

void sorted2_mode() {
	queue_t *q = queue_create_limited_sorted(3, 1, (void *)cmp_int_ptr);
	
	int t1 = 1;
  queue_put(q, &t1);
	int t2 = 15;
  queue_put(q, &t2);
	int t3 = 3;
  queue_put(q, &t3);
	int t4 = 27;
  queue_put(q, &t4);
	int t5 = 9;
  queue_put(q, &t5);
  
  int *i;
  queue_get(q, (void **)&i);
  printf("first element was %d\n", *i);
  queue_get(q, (void **)&i);
  printf("second element was %d\n", *i);
  queue_get(q, (void **)&i);
  printf("third element was %d\n", *i);
  queue_get(q, (void **)&i);
  printf("fourth element was %p\n", i);
  queue_get(q, (void **)&i);
  printf("fifth element was %p\n", i);
  
	queue_destroy_complete(q, NULL);
}

void sorted_mode() {
	queue_t *q = queue_create_sorted(1, (void *)cmp_int_ptr);
	
	int *t1 = malloc(sizeof(int));
	int *t2 = malloc(sizeof(int));
	int *t3 = malloc(sizeof(int));
	int *t4 = malloc(sizeof(int));
	
	*t1 = 10;
	*t2 = 12;
	*t3 = 1;
	*t4 = 1;
	
	queue_put(q, t1);
	queue_put(q, t2);
	queue_put(q, t3);
	queue_put(q, t4);
	
	int *t;
	queue_get(q, (void **)&t);
	printf("first int %i\n", *t);
	free(t);
	queue_get(q, (void **)&t);
	printf("second int %i\n", *t);
	free(t);
	queue_get(q, (void **)&t);
	printf("third int %i\n", *t);
	free(t);
	queue_get(q, (void **)&t);
	printf("fourth int %i\n", *t);
	free(t);
	
	queue_destroy_complete(q, NULL);
}

void *filterThreadFunc(void *arg) {
	CircularQueue* q = arg;
	QueueElem elem = queue_get(q);
	QueueElem first = elem;
	addPrimesToList(first);
	if(first  > (int) sqrt(N)){
		elem = queue_get(q);
		while(elem != 0) {
			
			addPrimesToList(elem);
			elem = queue_get(q);
		}
		sem_post(&canTerminate);
	}
	else {		
		pthread_t filterThreadId;
		CircularQueue* temp;
		queue_init(&temp, queueSize);
		if(pthread_create(&filterThreadId, NULL, filterThreadFunc, (void*) temp)) {
			printf("Thread error.");
		}	
		do {
			elem = queue_get(q);
			if(elem % first != 0)
				queue_put(temp, elem);
		} while (elem != 0);
		queue_put(temp, 0);
	}
	queue_destroy(q);
	return NULL;
}

void* Filter(void* q){
	QueueElem primo= queue_get(q);
	QueueElem temp= queue_get(q);
	//printf(" ler %d \n",temp);
	if(primo>ceil(sqrt(N))){
		while(temp!=0){
			// printf(" a ler finais : %d \n",temp);
			if(temp!=0){
				pthread_mutex_lock(&mutex2);
				primes[ind]=temp;
				ind++;
				pthread_mutex_unlock(&mutex2);
			}
			temp=queue_get(q);
		}
		pthread_mutex_lock(&mutex2);
		primes[ind]=primo;
		ind++;
		pthread_mutex_unlock(&mutex2);
		
		queue_destroy(q);
		sem_post(&semaforo);
	}
	else{
		CircularQueue* q2;
		queue_init(&q2,10);
		pthread_t ThreadPrimo;
		pthread_create(&ThreadPrimo,NULL,Filter,q2);

		// printf("thread created \n");
		pthread_mutex_lock(&mutex1);
		number_threads++;
		pthread_mutex_unlock(&mutex1);

		while(temp!=0){
			if(temp%primo!=0){
				queue_put(q2,temp);
				// printf(" por %d \n",temp);
			}	

			temp=queue_get(q);
			// printf(" ler %d \n",temp);

		}
		queue_put(q2,0);
		queue_destroy(q);

		pthread_mutex_lock(&mutex2);
		primes[ind]=primo;
		ind++;
		pthread_mutex_unlock(&mutex2);
	}

	pthread_mutex_lock(&mutex1);
	number_threads--;
	pthread_mutex_unlock(&mutex1);

	return NULL;
}

void *filter_thread(void *arg) {
	CircularQueue *entryQueue = (CircularQueue *) arg;
	
	CircularQueue *exitQueue;
	queue_init(&exitQueue, _max_number);
	
	unsigned int first = queue_get(entryQueue);
	
	if (place_number_into_shared_memory(first)) {
		printf("Error while accessing the shared memory region.\n");
		
		exit(EXIT_FAILURE);
	}
	
	#if DEBUG
	printf("Placed %d on the shared memory region.\n", first);
	#endif
	
	unsigned int number = 0;
	
	if (first > sqrt(_max_number)) {
		#if DEBUG
		printf("Finished, the rest are primes. (%d and up)\n", first);
		#endif
		
		while (( number = queue_get(entryQueue) ))	//	Get each number from the entry queue up until "0"
			place_number_into_shared_memory(number);
		
		//	Signal the EOP semaphore, we are done!
		
		sem_t *semaphore = sem_open(SEM1_NAME, 0, 0600, NULL);
		
		if (semaphore == SEM_FAILED) {
			printf("Error while getting the End of Program semaphore.\n");
			
			exit(EXIT_FAILURE);
		}
		
		sem_post(semaphore);
		
		return NULL;
	}
	
	pthread_t filter_tid;
	
	pthread_create(&filter_tid, NULL, filter_thread, exitQueue);
	
	while (( number = queue_get(entryQueue) ))	//	Get each number from the entry queue up until "0"
		if (number % first)	//	So far, the number is prime.
			queue_put(exitQueue, number);
	
	queue_put(exitQueue, 0);
	
	queue_destroy(entryQueue);
	
	return NULL;
}

static void
playlist_delete_internal(struct playlist *playlist, unsigned song,
			 const struct song **queued_p)
{
	unsigned songOrder;

	assert(song < queue_length(&playlist->queue));

	songOrder = queue_position_to_order(&playlist->queue, song);

	if (playlist->playing && playlist->current == (int)songOrder) {
		bool paused = pc_get_state() == PLAYER_STATE_PAUSE;

		/* the current song is going to be deleted: stop the player */

		pc_stop();
		playlist->playing = false;

		/* see which song is going to be played instead */

		playlist->current = queue_next_order(&playlist->queue,
						     playlist->current);
		if (playlist->current == (int)songOrder)
			playlist->current = -1;

		if (playlist->current >= 0 && !paused)
			/* play the song after the deleted one */
			playlist_play_order(playlist, playlist->current);
		else
			/* no songs left to play, stop playback
			   completely */
			playlist_stop(playlist);

		*queued_p = NULL;
	} else if (playlist->current == (int)songOrder)
		/* there's a "current song" but we're not playing
		   currently - clear "current" */
		playlist->current = -1;

	/* now do it: remove the song */

	if (!song_in_database(queue_get(&playlist->queue, song)))
		pc_song_deleted(queue_get(&playlist->queue, song));

	queue_delete(&playlist->queue, song);

	/* update the "current" and "queued" variables */

	if (playlist->current > (int)songOrder) {
		playlist->current--;
	}
}

void *doSum(void *arg) {
  int sum = 0;
  Queue *queue = (Queue*)arg;


  Task *task = (Task*)queue_get(queue);
  while(task) {
    sum += task->value;
    free(task);

    task = (Task*)queue_get(queue);
  }

  pthread_exit((void*)(intptr_t)sum);
}

static int i2s_stm32_read(struct device *dev, void **mem_block, size_t *size)
{
	struct i2s_stm32_data *const dev_data = DEV_DATA(dev);
	int ret;

	if (dev_data->rx.state == I2S_STATE_NOT_READY) {
		LOG_DBG("invalid state");
		return -EIO;
	}

	if (dev_data->rx.state != I2S_STATE_ERROR) {
		ret = k_sem_take(&dev_data->rx.sem, dev_data->rx.cfg.timeout);
		if (ret < 0) {
			return ret;
		}
	}

	/* Get data from the beginning of RX queue */
	ret = queue_get(&dev_data->rx.mem_block_queue, mem_block, size);
	if (ret < 0) {
		return -EIO;
	}

	return 0;
}

void join_threads(void) {
    cnode *curnode;
    printf("joining threads...\n");
    while (numthreads) {
        pthread_mutex_lock(&cq.control.mutex);
        /* below, we sleep until there really is a new cleanup node.  This
           takes care of any false wakeups... even if we break out of
           pthread_cond_wait(), we don't make any assumptions that the
           condition we were waiting for is true.  */
        while (cq.cleanup.head==NULL) {
            pthread_cond_wait(&cq.control.cond,&cq.control.mutex);
        }
        /* at this point, we hold the mutex and there is an item in the
           list that we need to process.  First, we remove the node from
           the queue.  Then, we call pthread_join() on the tid stored in
           the node.  When pthread_join() returns, we have cleaned up
           after a thread.  Only then do we free() the node, decrement the
           number of additional threads we need to wait for and repeat the
           entire process, if necessary */
        curnode = (cnode *) queue_get(&cq.cleanup);
        pthread_mutex_unlock(&cq.control.mutex);
        pthread_join(curnode->tid,NULL);
        printf("joined with thread %d\n",curnode->threadnum);
        free(curnode);
        numthreads--;
    }
}

static int
get_ports(ClientData clientData,
              Tcl_Interp *interp,
              int argc,
              char *argv[])
{
    char msg[255];
    channel_t *chan;
    int i, n;

    memset(msg, 0, 255);
    n = queue_length(priv_c);
    Tcl_SetResult(interp,NULL,TCL_STATIC);
    for(i = 0; i < n; i++) {
        chan = (channel_t*)queue_get(priv_c, i, Q_KEEP);
        sprintf(msg, "%d", chan->port);
        Tcl_AppendElement(interp,msg);
    }

    UNUSED(clientData);
    UNUSED(argc);
    UNUSED(argv);

    return TCL_OK;
}

void *write_thread(void *_ts) {
	struct ts *ts = _ts;
	struct packet *packet;

	mode_t umask_val = umask(0);
	dir_perm = (0777 & ~umask_val) | (S_IWUSR | S_IXUSR);

	set_thread_name("tsdump-write");
	while ((packet = queue_get(ts->packet_queue))) {
		if (!packet->data_len)
			continue;

		p_dbg1(" - Got packet %d, size: %u, file_time:%lu packet_time:%lu depth:%d\n",
			packet->num, packet->data_len, ALIGN_DOWN(packet->ts.tv_sec, ts->rotate_secs),
			packet->ts.tv_sec, ts->packet_queue->items);

		handle_files(ts, packet);

		if (ts->output_fd > -1) {
			p_dbg2(" - Writing into fd:%d size:%d file:%s\n", ts->output_fd, packet->data_len, ts->output_filename);
			ssize_t written = write(ts->output_fd, packet->data, packet->data_len);
			if (written != packet->data_len) {
				p_err("Can not write data (fd:%d written %zd of %d file:%s)",
					ts->output_fd, written, packet->data_len, ts->output_filename);
			}
		}
		free_packet(packet);
	}
	close_output_file(ts, NO_UNLINK);
	return NULL;
}

void *threadfunc(void *myarg) {
    wnode *mywork;
    cnode *mynode;
    mynode=(cnode *) myarg;
    pthread_mutex_lock(&wq.control.mutex);
    while (wq.control.active) {
        while (wq.work.head==NULL && wq.control.active) {
            pthread_cond_wait(&wq.control.cond, &wq.control.mutex);
        }
        if (!wq.control.active)
            break;
        //we got something!
        mywork=(wnode *) queue_get(&wq.work);
        pthread_mutex_unlock(&wq.control.mutex);
        //perform processing...
        printf("Thread number %d processing job %d\n",mynode->threadnum,mywork->jobnum);
        free(mywork);
        pthread_mutex_lock(&wq.control.mutex);
    }
    pthread_mutex_unlock(&wq.control.mutex);
    pthread_mutex_lock(&cq.control.mutex);
    queue_put(&cq.cleanup,(node *) mynode);
    pthread_mutex_unlock(&cq.control.mutex);
    pthread_cond_signal(&cq.control.cond);
    printf("thread %d shutting down...\n",mynode->threadnum);
    return NULL;

}

enum playlist_result
spl_save_queue(const char *name_utf8, const struct queue *queue)
{
	char *path_fs;
	FILE *file;

	if (map_spl_path() == NULL)
		return PLAYLIST_RESULT_DISABLED;

	if (!spl_valid_name(name_utf8))
		return PLAYLIST_RESULT_BAD_NAME;

	path_fs = map_spl_utf8_to_fs(name_utf8);
	if (path_fs == NULL)
		return PLAYLIST_RESULT_BAD_NAME;

	if (g_file_test(path_fs, G_FILE_TEST_EXISTS)) {
		g_free(path_fs);
		return PLAYLIST_RESULT_LIST_EXISTS;
	}

	file = fopen(path_fs, "w");
	g_free(path_fs);

	if (file == NULL)
		return PLAYLIST_RESULT_ERRNO;

	for (unsigned i = 0; i < queue_length(queue); i++)
		playlist_print_song(file, queue_get(queue, i));

	fclose(file);

	idle_add(IDLE_STORED_PLAYLIST);
	return PLAYLIST_RESULT_SUCCESS;
}