实验八 进程间通信+多线程

最新推荐文章于 2022-12-19 20:58:34 发布
最新推荐文章于 2022-12-19 20:58:34 发布
阅读量2.2k 收藏 15
点赞数 4
分类专栏： 大学嵌入式实验报告记录 文章标签： 实验八 进程间通信+多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/diOSyu/article/details/101237555
版权

一、实验目的

1、了解采用进程间通信的原理；

2、掌握线程的创建及使用方法，学习进行多线程编程。

二、实验内容

（1）在Linux系统下编写完成。

（2）创建一个服务器和若干个客户端。

（3）用户可以实现包括：通过客户端输入文字并且向服务器发送消息，也可以接收来自服务器端的数据。用户控制客户端退出。

（4）服务器端可以实现包括：接收并区分来自客户端的数据，将用户输入的内容在服务器上打印出来，并将原内容返回客户端。服务器可以通过单播或广播向客户端发送数据，并可以统计在线人数等。

（5）在服务器端和客户机端要综合运用多进程/多线程的编程知识实现并发处理，并且要在进程和线程之间采用相应的同步/互斥机制，实现其通信过程。

（6）最终采用makefile文件的形式予以实现。

三、源程序

（1）Python语言实现

server.py（服务器端）：

# -*- coding:utf-8 -*-



from threading import Thread

import socket

import os



# 绑定地址

ADDRESS = ('127.0.0.1', 8712)

# 负责监听的socket

g_socket_server = None

# 连接池

g_conn_pool = dict()



def show_help():

    print_info('help: 获取帮助信息')

    print_info('all:消息: 群发消息')

    print_info('name:消息: 单发消息')

    print_info('close: 关闭服务端')

    print_info('show online number: 显示当前在线人数')

    print_info('show online names: 显示当前在线用户名')



def print_info(s):

    print('SYSTEM>:', s)



def print_client(c, s):

    print(c + '>:', s)



def init():

    global g_socket_server

    # 创建 socket 对象

    g_socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    g_socket_server.bind(ADDRESS)

    # 最大等待数

    g_socket_server.listen(5)



def accept_client():

    """

    接收新连接

    """

    while True:

        # 阻塞，等待客户端连接

        client, _ = g_socket_server.accept()

        # 获取用户名

        client_name = client.recv(1024).decode(encoding='utf8')

        if client_name in g_conn_pool.keys() or client_name == 'all':

            client.sendall("该用户名已被使用".encode("utf8"))

            client.close()

        # 加入连接池

        g_conn_pool[client_name] = client

        # 给每个客户端创建一个独立的线程进行管理

        Thread(target=message_handle, args=(client, client_name), daemon=True).start()



def message_handle(client, client_name):

    """

    消息处理

    """

    while True:

        bs = client.recv(1024)

        if len(bs) == 0:

            client.close()

            # 删除连接

            g_conn_pool.pop(client_name)

            print_client(client_name, "下线了")

            break

        print_client(client_name, bs.decode(encoding='utf8'))



def close_server():

    global g_socket_server, g_conn_pool

    for v in g_conn_pool.values():

        if v is not None:

            v.close()

    g_conn_pool = None

    if g_socket_server is not None:

        g_socket_server.close()



if __name__ == '__main__':

    # 初始化

    init()

    # 新开一个线程，用于接收新连接

    Thread(target=accept_client, daemon=True).start()

    # 主线程逻辑

    inp = None

    try:

        while True:

            inp = input().strip()

            if inp == 'help':

                show_help()

            elif inp == 'close':

                close_server()

                os._exit(0)

            elif inp == 'show online number':

                print_info(len(g_conn_pool.keys()))

            elif inp == 'show online names':

                print_info(list(g_conn_pool.keys()))

            elif inp.startswith('all:') and len(inp) >= 5:

                info = inp[4:]

                for val in g_conn_pool.values():

                    val.sendall(info.encode(encoding='utf8'))

            elif ':' in inp:

                idx = inp.index(':')

                name = inp[:idx]

                info = inp[idx:]

                if name in g_conn_pool.keys() and len(info) >= 1:

                    g_conn_pool[name].sendall(info[1:].encode(encoding='utf8'))

                else:

                    print_info('输入命令错误')

            else:

                print_info('输入命令错误')

    finally:

        close_server()

client.py（客户端）：

# -*- coding:utf-8 -*-



from threading import Thread

import random

import socket

import os



ADDRESS = ('127.0.0.1', 8712)  # 绑定地址



g_socket_client = None



g_name = None



def print_server(s):

    print('Server>:', s)



def print_info(s):

    print('SYSTEM>:', s)



def show_help():

    print_info('help: 获取帮助信息')

    print_info('server:消息:发送消息给服务器')

    print_info('close:关闭客户端')



# 生成用户名

def get_name():

    char_list = []

    for i in range(10):

        char_list.append(str(i))

    for i in range(65, 91):

        char_list.append(chr(i))

    for i in range(97, 123):

        char_list.append(chr(i))

    my_slice = random.sample(char_list, 4)

    return ''.join(my_slice)



# 初始化

def init():

    global g_socket_client, g_name

    # 创建 socket 对象

    g_socket_client = socket.socket()

    g_socket_client.connect(ADDRESS)

    # 初始化用户名

    g_name = get_name()

    print_info('初始化用户名为' + g_name)

    g_socket_client.sendall(g_name.encode(encoding='utf8'))



def receive_message():

    global g_socket_client

    try:

        while True:

            msg = g_socket_client.recv(1024).decode(encoding='utf8')

            if len(msg) == 0:

                print_info('服务器端关闭, 客户端退出')

                os._exit(0)

            print_server(msg)

    finally:

        close_client()



# 关闭客户端

def close_client():

    global g_socket_client

    if g_socket_client is not None:

        g_socket_client.close()



if __name__ == '__main__':

    # 初始化

    init()

    # 启动接收线程

    Thread(target=receive_message, daemon=True).start()

    try:

        inp = None

        while True:

            inp = input().strip()

            if inp == 'close':

                print_info('关闭客户端')

                close_client()

                os._exit(0)

            elif inp == 'help':

                show_help()

            elif inp.startswith('server:') and len(inp) > 7:

                info = inp[7:]

                g_socket_client.sendall(info.encode(encoding='utf8'))

            else:

                print_info('输入命令错误')

    finally:

        close_client()

（2）C语言实现

server.c(服务器端)：

#include <stdio.h>

#include <stdlib.h>

#include <sys/socket.h>

#include <string.h>

#include <sys/types.h>

#include <arpa/inet.h>

#include <assert.h>

#include <unistd.h>

#include <netinet/in.h>

#include <netinet/ip.h>

#include <errno.h>

#include <pthread.h>

#include <stdbool.h>



#define SERVER_PORT 11332

#define MAX_CONN_LIMIT 8 //MAX connection limit

#define BUFFER_LENGTH 1024



// Server

struct sockaddr_in server_addr;

int server_sock_fd;

// Server Pool

int socket_pool[64];



char data_send[BUFFER_LENGTH];

char data_recv[BUFFER_LENGTH];



void init_server();



void init_pool();



void close_server();



void show_help();



int get_num();



int next_index();



void send_data(int sock_fd);



bool in_pool(int sock_fd);



static void accept_thread();



static void Data_handle(void *sock_fd);



int main() {

    setvbuf(stdout, NULL, _IONBF, 0);

    // 初始化

    init_server();

    init_pool();

    pthread_t thread_id;

    if (-1 == pthread_create(&thread_id, NULL, (void *) (&accept_thread), (void *) (NULL))) {

        perror("服务器端创建接收thread失败\n");

        exit(EXIT_FAILURE);

    }

    char input[64];

    while (1) {

        scanf("%s", input);

        if (strcmp(input, "CLOSE") == 0) {

            close_server();

            break;

        } else if (strcmp(input, "HELP") == 0) {

            show_help();

        } else if (strcmp(input, "ALL") == 0) {

            memset(data_send, 0, BUFFER_LENGTH);

            printf("请输入要发送的消息:");

            scanf("%s", data_send);

            for (int i = 0; i < 64; i++) {

                if (socket_pool[i] != -1) {

                    send_data(socket_pool[i]);

                }

            }

        } else if (strcmp(input, "NUM") == 0) {

            printf("当前在线人数为%d\n", get_num());

        } else if (strcmp(input, "ONE") == 0) {

            int tmp_fd;

            printf("请输入要发送的ID:");

            scanf("%d", &tmp_fd);

            if (!in_pool(tmp_fd)) {

                printf("该ID不存在\n");

                continue;

            }

            memset(data_send, 0, BUFFER_LENGTH);

            printf("请输入要发送的消息:");

            scanf("%s", data_send);

            send_data(tmp_fd);

        } else {

            printf("输入命令错误\n");

        }

    }

    return 0;

}



// 显示帮助

void show_help() {

    printf("NUM: 显示当前在线人数\n");

    printf("ALL: 向全体发消息\n");

    printf("ONE: 向部分发消息\n");

    printf("HELP: 显示帮助信息\n");

    printf("CLOSE: 关闭服务器端\n");

}



// 初始化服务器

void init_server() {

    // 初始化

    memset(&server_addr, 0, sizeof(struct sockaddr_in));

    // 使用 IPv4 进行通信

    server_addr.sin_family = AF_INET;

    // 设置端口

    server_addr.sin_port = htons(SERVER_PORT);

    // 指向IP

    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    // 初始化空字节

    bzero(&(server_addr.sin_zero), 8);

    // 创建socket

    server_sock_fd = socket(AF_INET, SOCK_STREAM, 0);

    if (-1 == server_sock_fd) {

        perror("服务器端Socket创建失败");

        exit(-1);

    }



    //  close socket后想继续重用该socket

    int on = 1;

    setsockopt(server_sock_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

    // 绑定

    int bind_result = bind(server_sock_fd, (struct sockaddr *) &server_addr, sizeof(server_addr));

    if (-1 == bind_result) {

        perror("服务器端Socket绑定失败");

        exit(-1);

    }



    // 置socket为listen模式

    int listen_result = listen(server_sock_fd, MAX_CONN_LIMIT);

    if (-1 == listen_result) {

        perror("服务器端Socket设置listen模式失败");

        exit(-1);

    }

}



// 初始化链接池

void init_pool() {

    memset(socket_pool, -1, sizeof(int) * 64);

}



// 关闭

void close_server() {

    int shutdown_result = shutdown(server_sock_fd, SHUT_WR);

    if (-1 == shutdown_result) {

        printf("服务器端Socket关闭异常\n");

        exit(-1);

    }

    printf("服务器端Socket正确关闭\n");

}



// 接收线程

void accept_thread() {

    int client_length;

    struct sockaddr_in s_addr_client;

    int client_sock_fd;

    while (1) {

        pthread_t thread_id;

        client_length = sizeof(s_addr_client);

        // Accept

        client_sock_fd = accept(server_sock_fd, (struct sockaddr_ *) (&s_addr_client), (socklen_t *) (&client_length));

        if (client_sock_fd == -1) {

            perror("服务器端Accept错误");

            continue;

        }

        printf("服务器端接收到一个新请求\n");

        if (pthread_create(&thread_id, NULL, (void *) (&Data_handle), (void *) (&client_sock_fd)) == -1) {

            perror("服务器端建立thread失败\n");

            break;

        }

        printf("该客户端ID为%d\n", client_sock_fd);

        // 存储

        int idx = next_index();

        if (idx == -1) {

            perror("服务器链接已满");

            exit(EXIT_FAILURE);

        } else {

            socket_pool[idx] = client_sock_fd;

        }

    }

}



// next INDEX

int next_index() {

    for (int i = 0; i < 64; i++) {

        if (socket_pool[i] == -1) {

            return i;

        }

    }

    return -1;

}



// 得到当前在线人数

int get_num() {

    int num = 0;

    for (int i = 0; i < 64; ++i) {

        if (socket_pool[i] != -1) {

            num += 1;

        }

    }

    return num;

}



// 是否在连接池中

bool in_pool(int sock_fd) {

    for (int i = 0; i < 64; i++) {

        if (socket_pool[i] == sock_fd) {

            return true;

        }

    }

    return false;

}



// 数据处理

static void Data_handle(void *sock_fd) {

    int fd = *((int *) sock_fd);

    int i_recvBytes;



    while (1) {

        //Reset data.

        memset(data_recv, 0, BUFFER_LENGTH);

        i_recvBytes = read(fd, data_recv, BUFFER_LENGTH);

        printf("i_recv = %d\n", i_recvBytes);

        if (i_recvBytes == 0) {

            printf("该客户端%d关闭\n", fd);

            break;

        } else if (i_recvBytes == -1) {

            perror("服务器端读取错误");

            break;

        } else {

            printf("客户端[%d]: %s\n", fd, data_recv);

        }



    }

    //Clear

    printf("客户端[%d]结束\n", fd);



    close(fd);            //close a file descriptor.

    pthread_exit(NULL);   //terminate calling thread!

}



// 发送消息

void send_data(int sock_fd) {

    int res = write(sock_fd, data_send, BUFFER_LENGTH);

    if (res == -1) {

        perror("发送失败");

        exit(EXIT_FAILURE);

    }

}

client.c（客户端）：

#include <stdio.h>

#include <stdlib.h>

#include <sys/socket.h>

#include <string.h>

#include <sys/types.h>

#include <arpa/inet.h>

#include <assert.h>

#include <unistd.h>

#include <netinet/in.h>

#include <netinet/ip.h>

#include <errno.h>

#include <pthread.h>

#include <stdbool.h>



#define SOCK_PORT 11332

#define BUFFER_LENGTH 1024



int sock_fd;

struct sockaddr_in s_addr_in;

char data_send[BUFFER_LENGTH];

char data_recv[BUFFER_LENGTH];

void init_client();

void show_help();

static void Data_read();

int main() {

    setvbuf(stdout, NULL, _IONBF, 0);



    init_client();



    pthread_t thread_id;

    if (-1 == pthread_create(&thread_id, NULL, (void *) (&Data_read), (void *) (NULL))) {

        perror("客户端创建接收thread失败\n");

        exit(EXIT_FAILURE);

    }



    char input[64];

    while (1) {

        gets(input);

        if (strcmp(input, "HELP") == 0) {

            show_help();

        } else if (strcmp(input, "CLOSE") == 0) {

            int ret = shutdown(sock_fd, SHUT_WR);

            assert(ret != -1);

            break;

        } else if (strcmp(input, "SEND") == 0) {

            memset(data_send, 0, BUFFER_LENGTH);

            printf("请输入要发送的数据:");

            scanf("%s", data_send);

            int write_res = write(sock_fd, data_send, BUFFER_LENGTH);

            if (write_res == -1) {

                perror("客户端写入失败\n");

                exit(-1);

            }

        }

    }



    return 0;

}



void init_client() {

    sock_fd = socket(AF_INET, SOCK_STREAM, 0);       //ipv4,TCP

    if (sock_fd == -1) {

        perror("客户端Socket创建失败");

        exit(-1);

    }

    memset(&s_addr_in, 0, sizeof(s_addr_in));

    s_addr_in.sin_addr.s_addr = inet_addr("127.0.0.1");

    s_addr_in.sin_family = AF_INET;

    s_addr_in.sin_port = htons(SOCK_PORT);

    int connect_res = connect(sock_fd, (struct sockaddr *) (&s_addr_in), sizeof(s_addr_in));

    if (connect_res == -1) {

        perror("客户端连接失败");

        exit(-1);

    }

    memset(data_send, 0, BUFFER_LENGTH);

    memset(data_recv, 0, BUFFER_LENGTH);

}



static void Data_read() {

    while (true)

    {

        int read_res = read(sock_fd, data_recv, BUFFER_LENGTH);

        assert(read_res != -1);

        if(read_res == 0)

        {

            printf("服务器端已关闭\n");

            exit(EXIT_SUCCESS);

        }

        printf("Server>: %s\n", data_recv);

        memset(data_recv, 0, BUFFER_LENGTH);

    }

}



void show_help() {

    printf("HELP:　显示帮助\n");

    printf("CLOSE: 关闭客户端\n");

    printf("SEND: 发送信息\n");

}

makefile如下：

all: server client



CC = gcc

SRC1 = server.c

SRC2 = client.c

OBJE1 = server

OBJE2 = client



${OBJE1}:

    ${CC} ${SRC1} -lpthread -w -o ${OBJE1}

${OBJE2}:

    ${CC} ${SRC2} -lpthread -w -o ${OBJE2} 

四、实验步骤、结果截图

1》Python运行结果：

  1. 服务器端显示帮助信息。输入help,系统会显示帮助信息。

  1. 运行客户端。首先，客户端会生成随机用户名，并将该用户名发送给服务器端，用作该客户端的标识。

再增加一个客户端：

  1. 客户端显示帮助信息。输入help, 会显示帮助信息。如下：

(4)服务器端显示当前在线人数。输入show online number，系统会显示当前在线人数。

  1. 服务器端显示当前登录用户名。输入show online names，系统会显示当前在线用户名。

 

  1. 服务器端单发信息。例如，向用户名为glXc单发信息。如下：

相应客户端收到信息。如下：

  1. 服务器端群发消息。例如，输入all:Hello!。如下：

 

所有客户端都收到了该消息。如下：

glXc客户端:

RL4m客户端：

 

  1. 客户端输入close,来关闭程序。同时，服务器端显示该客户端下线。如下：

  1. 客户端向服务器端发送消息。例如，输入server:Hello From 4VRh!。如下：

服务器端接收到该消息。如下：

  1. 服务器端关闭程序，客户端自动关闭。如下：

客户端自动关闭。如下：

2》C语言运行结果：

  1. 编译程序。使用make　all，生成server和client文件。

  1. 运行服务器端和两个客户端。服务器端如下：

(3)

  1. 服务器端显示帮助信息。输入HELP命令，如下：

  1. 客户端获取帮助信息。输入HELP命令，如下：

  1. 服务器端单发消息。输入ONE命令，如下：

客户端接收到消息，如下：

  1. 服务器端群发消息。输入ALL命令，如下：

 

客户端结果：

  1. 关闭客户端。使用CLOSE命令:

同时，服务器端收到通知。如下：

  1. 关闭服务器端。使用CLOSE命令。如下：

客户端收到通知自动关闭。如下：

 

void1024
关注
  • 4
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统实验 # 图书馆阅览室问题 伪码及编程实现
skysys的研究小屋
05-13 5285
问题描述：假定阅览室最多可同时容纳100个人阅读，读者进入时，必须在阅览室门口的一个登记表上登记，内容包括姓名、座号等，离开时要撤掉登记内容。用P、V操作描述读者进程的同步算法。 原理及代码解读见我的另一篇文章：操作系统 # 从零开始的信号量机制理论与实践 https://blog.csdn.net/qq_33583069/article/details/105877936 link~ 伪代码实现 var mutex,res:semaphore; mutex:=1; res:=100; Procedur
JAVA实验8 多线程编程
代码不会敲的博客
05-01 1665
实验8 多线程编程 实验要求： （1）掌握两种创建线程的方法； （2）掌握线程同步的方法。 实验内容： （1）编程模拟售票系统，模拟多个窗口（至少4个）同时出售100张车票的情况；用实现Runnable接口的方法实现多线程。 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class TicketSell { public static void main
嵌入式操作系统实验——进程间通信Socket（2）
无名小卒的博客
05-27 2424
一、实验目的 1、了解采用Socket通信的原理。 2、掌握Socket的创建及使用方法。 二、实验内容 1、创建一个服务器端和若干个客户端。 服务器端可实现包括：接收并区分来自客户端的数据，将用户输入的内容在服务器上输出，并将原内容群发至所有在线客户端（类似qq群聊形式）；服务器可主动向在线客户端发送数据；并可以统计在线人数等。 客户端可实现包括：输入文字并且向服务器发送消息，接收来自服务器端的数据；用户控制客户端退出。 2、在服务器端和客户端基于socket实现其通信过程。 3、 服务器与客户端的具体内
Java实验8 多线程编程
qq_43283830的博客
05-28 929
实验8 多线程编程 实验要求： （1） 掌握两种创建线程的方法； （2） 掌握线程同步的方法。 实验内容： （1） 编程模拟售票系统，模拟多个窗口（至少4个）同时出售100张车票的情况；用实现Runnable接口的方法实现多线程。 /** * @author 张小桌桌 * 编程模拟售票系统，模拟多个窗口（至少4个）同时出售100张车票的情况； * 用实现Runnable接口的方法实现多线程。 */ package shiyan8; public class EightA implements R
操作系统课程设计：Linux系统调用/基于模块的文件系统/Linux驱动/统计Linux系统缺页的次数 整合
zombotany的博客
01-30 7933
目录一、可选题目题目1：新增Linux系统调用题目2：实现基于模块的文件系统题目3：新增Linux驱动程序题目4：统计Linux系统缺页的次数题目5：进程/线程通信二、操作顺序附录：参考资料题1题2题3题4题5 一、可选题目 题目1：新增Linux系统调用 采用编译内核法，在Linux中增加一个系统调用。 要求： （1）系统调用实现的功能：计算一个数字的三次方，并打印出来。 （2）另外写一个程序进行调用。 题目2：实现基于模块的文件系统 修改ext3或ext4的源代码，实现新的文件系统。 要求： （1）复制
Python多进程并发与多线程并发编程实例总结
12-25
本文实例总结了Python多进程并发与多线程并发。分享给大家供大家参考，具体如下： 这里对python支持的几种并发方式进行简单的总结。 Python支持的并发分为多线程并发与多进程并发（异步IO本文不涉及）。概念上来说，...
进程间通信_读者-写者问题.doc
06-17
互斥同步类CMutex和临界区同步类CCriticalSection都是用于保证一个资源一次只能有一个线程访问，二者的不同之处在于前者允许有多个应用程序使用该资源，例如，该资源在一个DLL当中，而后者则不允许对同一个资源的...
实验二.多线程应用程序设计
02-06
多线程应用程序设计是指在一个进程中运行多个线程，每个线程共享进程的资源，包括打开的文件、页表、信号标识及动态分配的内存等等。线程技术可以让程序更快、更高效、更方便地处理多任务操作。 1. 多线程概述 多...
操作系统实验3-进程通信.doc
12-22
在实验四中，学生需要编写服务器端和客户端两个程序，使用线程实现进程间通信，编译后分别在不同终端运行程序，二者间可相互进行通信。 进程间通信的重要性 进程间通信是操作系统中非常重要的一部分，因为它可以...
Linux下多线程及多进程及同步与互斥编程详细介绍
09-02
Linux下多线程及多进程及同步与互斥编程详细介绍
操作系统大作业（对问题进行问题分析+流程图+代码）
05-05
9.有三个进程R，M，P，其中R负责从输入设备读入信息并传送给M，M将信息加工并传送给P，P将打印输出，写出下列条件下的并发进程程序描述。 （1）一个缓冲区，其容量为K。 （2）两个缓冲区，每个缓冲区容量均为K。 10.假定一个阅览室最多可以容纳100人阅读，读者进入和离开阅览室时都必须在阅览室门口的一个登记表上注册或注销。假定每次只允许一个人注册或注销，设阅览室内有100个座位。 （1）试问：应编制几个程序和设置几个进程？程序和进程的对应关系如何？ （2）试用P、V操作编写读者进程的同步算法。
阅览室问题C语言实现
04-22
阅览室里有20个座位，外面有10个等待位，若读者来时发现等待位已满则离去。用C语言多线程实现，用信号量实现同步互斥
linux 进程间通信及多线程操作源码
02-27
全双工邮箱通讯，两个程序分别同过共享内存(邮箱)相互传输数据， 分别都有一个读写线程，读写个自通讯数据区域，一个读线程对应另一个进程的写线程；
进程、线程和进程间通信——线程的创建和回收
Riley_L的博客
12-19 122
Linux进程、线程和进程间通信——线程的创建和回收。 什么是线程？进程和线程之间有什么区别？为什么要有线程？线程的基础命令的使用：创建、回收、结束、分离、查看、以及线程的参数传递。
【进程、线程和进程间通信】（一）进程编程
weixin_50964793的博客
09-04 668
进程概念、常用命令、进程的创建和回收、exec函数族、守护进程、gdb调试多进程
多线程——线程通信代码
zjhzxjq的博客
03-06 162
1、多线程——线程通信代码 class PrintNum implements Runnable{ int num = 1; public void run(){ while (true){ synchronized (this) { notify(); if (num &lt;...
实验四Linux 进程之间的通信
weixin_43647522的博客
11-24 6348
实验4 进程之间的通信 实验性质：验证性 实验学时：4学时 一、实验目的 1.掌握管道、信号、共享内存、消息队列等进程间通信机制； 2.能够利进程间通信机制求解一些常见问题。 二、实验预备知识 1.阅读并掌握C语言基本语法，操作。 2.熟悉Linux常用命令及使用方法。 3.实验内容 编写程序实现以下功能： 利用匿名管道实现父子进程间通信，要求 父进程发送字符串“hello child”给子进程...
多进程和多线程编程操作
xiyouxiaotang的博客
08-18 1956
1.什么是进程 进程是系统最小的资源管理单元，是一个程序在一个数据集上的一次动态执行过程。 2.什么是线程 线程是计算机程序运行的实际执行者，是cpu的执行单元，在计算机中，进程主要是为了线程的执行进行分配资源操作，程序真正的执行者是线程，每一个进程至少有一个线程用于执行程序。一个进程可以有多个线程，而一个线程只服务于一个进程。 3.程序执行方法 串行   按照一定的步骤执行每个环节 ...
实验8:进程间高级通信
weixin_45475629的博客
04-02 4046
实验8:进程间高级通信 1、实验目的 (1)掌握如何利用管道机制、消息缓冲队列、共享存储区机制进行进程间的通信; (2)加深对上述通信机制的理解。 2、实现设备 一台装有windows 操作系统和 Linux机系统的微机或服务器。 3、实验方法与注意事项 实验室内的实验环境与系统是共用设施,请不要在系统内做对系统或对其他用户不安全的事情。 要求每个同学登录后系统后，要在自己的家目录内容以自己(拼音)名字或学号，创建一个子目录（已有者可以不再创建)。以后所有工作都要在自己的目录内进行。建议以后
进程间通信能用于线程间
最新发布
05-04
而线程间通信（Inter-Thread Communication，ITC）则是指在同一个进程的多个线程之间传输数据或者信息的机制。 虽然它们的名称不同，但是它们之间的机制是相似的，都需要通过某种方式来传输数据或者信息。因此，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值