进程间通讯

于 2018-11-25 13:27:40 发布
阅读量165 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43258242/article/details/84486029
版权

基本知识点:

（1）现在Linux使用的进程间通信方式包括：
1、管道（pipe）和有名管道（FIFO）
2、信号（signal）
3、消息队列
4、共享内存
5、信号量

（2）管道通信

  1. 管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。
    一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据

  2. 数据被一个进程读出后，将被从管道中删除，其它读进程将不能再读到这些数据。
    管道提供了简单的流控制机制，进程试图读空管道时，进程将阻塞。同样，管道已经满时，进程再试图向管道写入数据，进程将阻塞

  3. 管道包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者可用于运行于同一系统中的任意两个进程间的通信。
    无名管道创建：
    int pipe(int filedis[2])；
    当一个管道建立时，它会创建两个文件描述符：
    filedis[0] 用于读管道，
    filedis[1] 用于写管道

  1. 管道用于不同进程间通信。通常先创建一个管道，再通过fork函数创建一个子进程，该子进程会继承父进程所创建的管道
    必须在系统调用fork( )前调用pipe( )，否则子进程将不会继承文件描述符

（3）信号通信

  1. 信号(signal)机制是Unix系统中最为古老的进程间通信机制，很多条件可以产生一个信号：
    1、当用户按某些按键时，产生信号
    2、硬件异常产生信号：除数为0、无效的存储访问等等。这些情况通常由硬件检测到，将其通知内核，然后内核产生适当的信号通知进程，例如，内核对正访问一个无效存储区的进程产生一个SIGSEGV信号
 3、进程用kill函数将信号发送给另一个进程
    4、用户可用kill命令将信号发送给其他进程

  2. 下面是几种常见的信号：
    § SIGHUP： 从终端上发出的结束信号
    § SIGINT： 来自键盘的中断信号（Ctrl-C）
    § SIGKILL：该信号结束接收信号的进程
    § SIGTERM：kill 命令发出的信号
    § SIGCHLD：标识子进程停止或结束的信号
    § SIGSTOP：来自键盘（Ctrl-Z）或调试程序的停止执行信号

  3. 当某信号出现时，将按照下列三种方式中的一种进行处理：
    1、忽略此信号
    大多数信号都按照这种方式进行处理，但有两种信号
    决不能被忽略,它们是： SIGKILL\SIGSTOP。
    这两种信号不能被忽略的原因是：
    它们向超级用户提供了一种终止或停止进程的方法
    2、执行用户希望的动作
    通知内核在某种信号发生时，调用一个用户函数。在用户函数中， 执行用户希望的处理

    3、执行系统默认动作
    对大多数信号的系统默认动作是终止该进程

  4. 发送信号的主要函数有 kill和raise。 区别：
    Kill既可以向自身发送信号，也可以向其他进程发送信号。与kill函数不同的是，raise函数是向进程自身发送信号
    #include <sys/types.h>
    #include <signal.h>
    int kill(pid_t pid, int signo)
    int raise(int signo)
    5.kill的pid参数有四种不同的情况：
    1、pid>0
    将信号发送给进程ID为pid的进程。
    2、pid == 0
    将信号发送给同组的进程。
    3、pid < 0
    将信号发送给其进程组ID等于pid绝对值的进程。
    4、pid ==－1
    将信号发送给所有进程。

  5. alarm

  6. 使用alarm函数可以设置一个时间值(闹钟时间)，当所设置的时间到了时，产生SIGALRM信号.如果不捕捉此信号，则默认动作是终止该进程
    #include <unistd.h>
    unsigned int alarm(unsigned int seconds)
    Seconds：
    经过了指定的seconds秒后会产生信号SIGALRM。

  7. 每个进程只能有一个闹钟时间.如果在调用alarm时，以前已为该进程设置过闹钟时间，而且它还没有超时，以前登记的闹钟时间则被新值代换
    如果有以前登记的尚未超过的闹钟时间，而这次seconds值是0，则表示取消以前的闹钟

（4）共享内存

  1. 共享内存
    是被多个进程共享的一部分物理内存.共享内存是进程间共享数据的一种最快的方法，一个进程向共享内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容.

  2. 共享内存实现分为两个步骤:
    一、创建共享内存，使用shmget函数
    二、映射共享内存，将这段创建的共享内存映射到具体的进程空间去，使用shmat函数

3.创建
int shmget ( key_t key, int size, int shmflg )
key标识共享内存的键值: 0/IPC_PRIVATE。 当key的取值为IPC_PRIVATE，则函数shmget()将创建一块新的共享内存；如果key的取值为0，而参数shmflg中又设置IPC_PRIVATE这个标志，则同样会创建一块新的共享内存。
返回值：如果成功，返回共享内存标识符；如果失败，返回-1

4.映射
char * shmat ( int shmid, char *shmaddr, int flag)
参数：
shmid：shmget函数返回的共享存储标识符
flag：决定以什么方式来确定映射的地址（通常为0）
返回值：
如果成功，则返回共享内存映射到进程中的地址；如果失败，则返回- 1

5.解除映射
当一个进程不再需要共享内存时，需要把它从进程地址空间中脱离。
int shmdt ( char *shmaddr )

（5）消息队列

unix早期通信机制之一的信号能够传送的信息量有限，管道则只能传送无格式的字节流，这无疑会给应用程序开发带来不便。消息队列（也叫做报文队列）则克服了这些缺点。

消息队列就是一个消息的链表.可以把消息看作一个记录，具有特定的格式.进程可以向中按照一定的规则添加新消息;另一些进程则可以从消息队列中读走消息

3.键值
消息队列的内核持续性要求每个消息队列都在系统范围内对应唯一的键值，所以，要获得一个消息队列的描述字，必须提供该消息队列的键值
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok (char*pathname, char proj)
功能： 返回文件名对应的键值。
pathname: 文件名
proj: 项目名（不为0即可）

  1. 打开/创建
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    int msgget(key_t key, int msgflg)

key：键值，由ftok获得。
msgflg：标志位。
返回值：与健值key相对应的消息队列描述字
IPC_CREAT
创建新的消息队列
IPC_EXCL
与IPC_CREAT一同使用，表示如果要创建的消息队列已经存在，则返回错误。
IPC_NOWAIT
读写消息队列要求无法得到满足时，不阻塞

  1. 发送消息
    include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    int msgsnd(int msqid,struct msgbuf*msgp,int msgsz,int msgflg)
    功能：向消息队列中发送一条消息

Msqid: 已打开的消息队列id
Msgp: 存放消息的结构
Msgsz: 消息数据长度
Msgflg:
发送标志，有意义的msgflg标志为IPC_NOWAIT，指明在消息队列没有足够空间容纳要发送的消息时，msgsnd是否等待

6.消息格式
struct msgbuf
{
long mtype；/消息类型/
char mtext[1]; /消息数据的首地址/
}

7.接收消息
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgrcv(int msqid, struct msgbuf *msgp, int msgsz, long msgtyp, int msgflg)
功能：
从msqid代表的消息队列中读取一个msgtyp类型的消息，并把消息存储在msgp指向的msgbuf结构中。在成功地读取了一条消息以后，队列中的这条消息将被删除

（6）信号量

信号量(又名：信号灯)与其他进程间通信方式不大相同，主要用途是保护临界资源.
进程可以根据它判定是否能够访问某些共享资源。除了用于访问控制外，还可用于进程同步

2.分类
二值信号灯：信号灯的值只能取0或1，类似于互斥锁。 但两者有不同：
信号灯强调共享资源，只要共享资源可用，其他进程同样可以修改信号灯的值；
互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。
计数信号灯：信号灯的值可以取任意非负值

第一 kill的代码（linux1/ lesson2/test1.c/kill.c）

代码1. test(死循环)

#include <stdio.h>

int main()
{
while (1);

return 0;

}

代码 2. kill（信号）

#include <stdio.h>
#include <sys/types.h>
#include <signal.h>

int main()
{
int pid;

//scanf("%d", &pid);
//kill(pid, SIGINT);   //给pid进程发送SIGINT信号
raise(SIGINT);       //给进程本身发送信号

while (1);

return 0;

}

kill -l (查看所有的kill的信号命令)
kill -9（最高级别的命令）
kill -9 - 17111（向这个进程号发送9这个命令）

第二 signal的代码（linux1/ lesson2/signal.c）

#include <stdio.h>
#include <signal.h>

void handler(int sig)
{
printf(“recv %d\n”, sig); //sig 就是代表signal 中的2
}

int main()
{
//signal(2, SIG_IGN);
signal(2, handler); // 用信号函数

while (1);
return 0;

}

第三 pipe（无名管道）（linux1/ lesson3/pipe.c）

注意：（1）无名管道——》用于父子进程间的通信
（2）int pipe(int filedis[2])——》1. filedis[0] 读
2.filedis[1]写
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int main()
{
int ret, fd[2] = {0};
pid_t pid;
char buf[32] = {0};

ret = pipe(fd);      //创建无名管道
if (-1 == ret)
{
	perror("pipe");
	exit(1);
}

pid = fork();    // 创建进程
if (-1 == pid)
{
	perror("fork");
	exit(1);
}
else if (0 == pid)
{
	while (1)
	{
		scanf("%s", buf);
		ret = write(fd[1], buf, strlen(buf));   //写管道 fd[1]
		if (-1 == ret)
		{
			perror("write");
		}
		if (!strcmp(buf, "bye"))   //输入关键字bye 退出循环
		{
			break;
		}
		memset(buf, 0, sizeof(buf));
	}
}
else     //父进程，读管道
{
	while (1)
	{
		ret = read(fd[0], buf, sizeof(buf));   //fd[0]用于读管道
		if (-1 == ret)
		{
			perror("read");
		}
		if (!strcmp(buf, "bye"))
		{
			break;
		}
		printf("\t\t\t%s\n", buf);
		memset(buf, 0, sizeof(buf));
	}

	int status;
	waitpid(pid, &status, 0);
}

return 0;

}

第四 mkfifo（创建有名管道）（linux1/ lesson3/mkfifo_read.c/mkfifo_write.c）

代码一 mkfifo_read.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>

int main()
{
int ret, fd;
char buf[32] = {0};

ret = mkfifo("fifo.tmp", 00700);   //创建有名管道
if (-1 == ret)
{
	perror("mkfifo");
}

fd = open("fifo.tmp", O_RDONLY);
if (-1 == fd)
{
	perror("open");
	exit(1);
}

while (1)
{
	ret = read(fd, buf, sizeof(buf));
	if (-1 == ret)
	{
		perror("read");
	}
	if (!strcmp(buf, "bye"))
	{
		break;
	}
	printf("%s\n", buf);

	memset(buf, 0, sizeof(buf));
}

unlink("fifo.tmp");  //删除文件

return 0;

}

代码二 mkfifo_write.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

int main()
{
int fd, ret;
char buf[32] = {0};

fd = open("fifo.tmp", O_WRONLY);
if (-1 == fd)
{
	perror("open");
	exit(1);
}

while (1)
{
	scanf("%s", buf);
	ret = write(fd, buf, strlen(buf));
	if (-1 == ret)
	{
		perror("write");
	}
	if (!strcmp(buf, "bye"))
	{
		break;
	}
		
	memset(buf, 0, sizeof(buf));
}

return 0;

}

第五 alarm（闹钟）

#include <stdio.h>
#include <unistd.h>

int i = 0;

void print(int sig)
{
printf(“helloworld %d\n”, i++);
alarm(1);
}

int main()
{
alarm(1); //1秒后给进程本身发送SIGALRM信号，有效期1次
signal(14, print); // 14 就代表alarm这个信号

while (1);

return 0;

}

第六 (消息队列) msgqueue

注意点： （1）先运行的进程——》创建队列
（2）发送消息时候有格式要求， 读取消息时候， 读取对应的格式下的内容。
（3）格式和要发送的内容用一个结构体包含
（4）创建获取消息队列（msgget()）
（5）msgsnd(发送) msgcv（接收）
（6）删除队列（msgctl）
（7）ipcs（查看消息队列）
（8）ipcs -q（只查看队列）
（9）ipcs -m(共享内存)
（10）ipcs -s（信号量数组）
（11）ipcrm -q 32768（删除队列）

代码一 msqueue1.c(linux1/lesson3/msqueue1.c)
互相发送消息

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

#define MSGKEY 1234

struct msgbuf
{
long mtype; /* message type, must be > 0 /
char mtext[128]; / message data */
};

int main()
{
int msgid, ret;
struct msgbuf m;
pid_t pid;

msgid = msgget(MSGKEY, IPC_CREAT | IPC_EXCL);  //创建消息队列
if (-1 == msgid)
{
	perror("msgget");
	exit(1);
}

pid = fork();
if (-1 == pid)
{
	perror("fork");
	exit(1);
}
else if (pid > 0)   //父进程接收
{
	while (1)
	{
		ret = msgrcv(msgid, &m, sizeof(m.mtext), 1, 0);
		if (-1 == ret)
		{
			perror("msgrcv");
		}
		if (!strcmp(m.mtext, "bye"))
		{
			kill(pid, 9);
			break;
		}

		printf("\t\t%s\n", m.mtext);
		bzero(m.mtext, sizeof(m.mtext));
	}
}
else if (0 == pid)   //子进程发送
{
	while (1)
	{
		scanf("%s", m.mtext);
		m.mtype = 2;
		ret = msgsnd(msgid, &m, sizeof(m.mtext), 0);
		if (-1 == ret)
		{
			perror("msgsnd");
		}
		if (!strcmp(m.mtext, "bye"))
		{
			m.mtype = 1;
			msgsnd(msgid, &m, sizeof(m.mtext), 0);
			break;
		}

		bzero(m.mtext, sizeof(m.mtext));
	}
	int status;
	wait(&status);
}

msgctl(msgid, IPC_RMID, NULL);   //删除消息队列

return 0;

}

代码二 msqueue2.c (linux1/lesson3/msqueue2.c)

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

#define MSGKEY 1234

struct msgbuf {
long mtype; /* message type, must be > 0 /
char mtext[128]; / message data */
};

int main()
{
int msgid, ret;
struct msgbuf m;
pid_t pid;

msgid = msgget(MSGKEY, 0);  //获取消息队列
if (-1 == msgid)
{
	perror("msgget");
	exit(1);
}

pid = fork();
if (-1 == pid)
{
	perror("fork");
	exit(1);
}
else if (0 == pid)   //子进程发送
{
	while (1)
	{
		scanf("%s", m.mtext);
		m.mtype = 1;
		ret = msgsnd(msgid, &m, sizeof(m.mtext), 0);
		if (-1 == ret)
		{
			perror("msgsnd");
		}
		if (!strcmp(m.mtext, "bye"))
		{
			m.mtype = 2;
			msgsnd(msgid, &m, sizeof(m.mtext), 0);
			break;
		}

		bzero(m.mtext, sizeof(m.mtext));
	}
}
else   //父进程接收
{
	while (1)
	{
		ret = msgrcv(msgid, &m, sizeof(m.mtext), 2, 0);
		if (-1 == ret)
		{
			perror("msgrcv");
		}
		if (!strcmp(m.mtext, "bye"))
		{
			kill(pid, 9);
			break;
		}

		printf("\t\t%s\n", m.mtext);
		bzero(m.mtext, sizeof(m.mtext));
	}
	int status;
	wait(&status);
}

return 0;

}

第七：（共享内存）shm1/shm2

代码一（进程同时）（Linux1/lesson4/shm11.c）
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define SHMKEY 1234
#define SHMSIZE 4096
#define SEMKEY 1234

union semun {
int val; /* Value for SETVAL */
struct semid_ds buf; / Buffer for IPC_STAT, IPC_SET */
unsigned short array; / Array for GETALL, SETALL */
struct seminfo __buf; / Buffer for IPC_INFO(Linux specific) */
}; //用于信号量初始化（详情见man手册）

void sem_p(int id)
{
struct sembuf s;
s.sem_num = 0; //表示第一个信号量
s.sem_op = -1; //减一（加负一）操作
s.sem_flg = SEM_UNDO; //如果进程异常退出，信号量恢复初始状态
int ret = semop(id, &s, 1); //1表示信号量个数
if (-1 == ret)
{
return;
}
}

void sem_v(int id)
{
struct sembuf s;
s.sem_num = 0; //表示第一个信号量
s.sem_op = 1; //加一操作
s.sem_flg = SEM_UNDO; //如果进程异常退出，信号量恢复初始状态
int ret = semop(id, &s, 1); //1表示信号量个数
if (-1 == ret)
{
return;
}
}

int main()
{
int shmid; //共享内存返回值
void *shmaddr;
int num = 0, ret;
int semid; //信号量返回值

/*创建共享内存 共享内存键值（唯一）、共享内存大小（页为单位）、表示创建共享内存*/
shmid = shmget(SHMKEY, SHMSIZE, IPC_CREAT | IPC_EXCL);
if (-1 == shmid)
{
	perror("shmget");
	exit(1);
}

//共享内存映射
shmaddr = shmat(shmid, NULL, 0);
if (NULL == shmaddr)
{
	perror("shmat");
	exit(1);
}

//创建信号量  信号量键值 创建1个信号量
semid = semget(SEMKEY, 1, IPC_CREAT | IPC_EXCL);
if (-1 == semid)
{
	perror("semget");
	exit(1);
}

//初始化信号量
union semun unsem;
unsem.val = 1;      //信号量初始值（二值信号量）
ret = semctl(semid, 0, SETVAL, unsem);   //0表示第一个信号量 SETVAL表示初始化信号量
if (-1 == ret)
{
	perror("semctl");
	exit(1);
}

*(int *)shmaddr = num;         //把数据写到共享内存

while (1)
{
	sem_p(semid);          //p操作（减一）
	num = *(int *)shmaddr;     //读取数据
	if (num > 100)
	{
		break;
	}
	usleep(5000);
	printf("Process %d num = %d\n", getpid(), num);
	num++;
	*(int *)shmaddr = num;     //写回共享内存
	sem_v(semid);          //v操作（加一）
}

//解除映射
shmdt(shmaddr);

//删除共享内存
shmctl(shmid, IPC_RMID, NULL);
//删除信号量
semctl(semid, 0, IPC_RMID);   

return 0;

}

代码二（进程同时）（Linux1/lesson4/shm22.c）

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define SHMKEY 1234
#define SHMSIZE 4096
#define SEMKEY 1234

union semun {
int val; /* Value for SETVAL */
struct semid_ds buf; / Buffer for IPC_STAT, IPC_SET */
unsigned short array; / Array for GETALL, SETALL */
struct seminfo __buf; / Buffer for IPC_INFO(Linux specific) */
}; //用于信号量初始化（详情见man手册）

void sem_p(int id)
{
struct sembuf s;
s.sem_num = 0; //表示第一个信号量
s.sem_op = -1; //减一（加负一）操作
s.sem_flg = SEM_UNDO; //如果进程异常退出，信号量恢复初始状态
int ret = semop(id, &s, 1); //1表示信号量个数
if (-1 == ret)
{
return;
}
}

void sem_v(int id)
{
struct sembuf s;
s.sem_num = 0; //表示第一个信号量
s.sem_op = 1; //加一操作
s.sem_flg = SEM_UNDO; //如果进程异常退出，信号量恢复初始状态
int ret = semop(id, &s, 1); //1表示信号量个数
if (-1 == ret)
{
return;
}
}

int main()
{
int shmid; //共享内存返回值
void *shmaddr;
int num = 0, ret;
int semid; //信号量返回值

/*获取共享内存 共享内存键值（唯一）、共享内存大小（页为单位）*/
shmid = shmget(SHMKEY, SHMSIZE, 0);
if (-1 == shmid)
{
	perror("shmget");
	exit(1);
}

//共享内存映射
shmaddr = shmat(shmid, NULL, 0);
if (NULL == shmaddr)
{
	perror("shmat");
	exit(1);
}

//获取信号量  信号量键值
semid = semget(SEMKEY, 1, 0);
if (-1 == semid)
{
	perror("semget");
	exit(1);
}

/*//初始化信号量
union semun unsem;
unsem.val = 1;      //信号量初始值（二值信号量）
ret = semctl(semid, 0, SETVAL, unsem);   //0表示第一个信号量 SETVAL表示初始化信号量
if (-1 == ret)
{
	perror("semctl");
	exit(1);
}*/

while (1)
{
	sem_p(semid);          //p操作（减一）
	num = *(int *)shmaddr;     //读取数据
	if (num > 100)
	{
		break;
	}
	usleep(5000);
	printf("Process %d num = %d\n", getpid(), num);
	num++;
	*(int *)shmaddr = num;     //写回共享内存
	sem_v(semid);          //v操作（加一）
}

//解除映射
shmdt(shmaddr);

return 0;

}

周伟中
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python中的进程间通信
12-20
Python中的进程间通信（IPC，Inter-Process Communication）是指不同进程之间交换信息的方式。在多进程编程中，由于进程间的独立性，它们不能直接访问彼此的内存空间，因此需要通过特定的方法来协调和同步进程间的...
进程控制理论<二>---那些年我们一起学习linux程序设计
java开发指南博客 【转载】
06-20 73
进程通信 目的: 为什么进程间需要通信？ (1)数据传输 一个进程需要将它的数据发送给另一个进程 (2)资源共享 多个进程之间共享同样的资源 (3)通知事件 一个进程需要向另一个或一组进程发送消息，通知他们发生了某事件 (4)进程控制 有些进程希望完全控制另一个进程的执行（如：debug进程） 此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变。 ...
无名管道和有名管道
qq_37924084的博客
03-20 277
无名管道： 无名管道创建：int pipe(int filedis[2])；     当一个管道建立时，它会创建两个文件描述符：       filedis[0] 用于读管道，       filedis[1] 用于写管道 管道用于不同进程间通信。通常先创建一个管道，再通过fork函数创建一个子进程，该子进程会继承父进程所创建的管道
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
C#使用SendMessage实现进程间通信的方法
09-03
在C#编程中，进程间通信（IPC，Inter-Process Communication）是一种允许不同进程之间交换数据的技术。在本文中，我们将探讨如何使用Windows API中的`SendMessage`函数在两个C#进程中实现这一通信方式。 `...
Messenger进程间通信
03-15
在Android系统中，进程间通信（IPC，Inter-Process Communication）是实现不同应用程序或同一应用内不同进程之间数据共享和协同工作的重要手段。"Messenger进程间通信"是一种轻量级的IPC方式，常用于简单的双向通信...
进程间通信
12-23
进程间通信（Inter-Process Communication, IPC）是操作系统中一种重要的技术，允许不同的进程之间共享数据、协调工作。在多任务或并发环境下，进程间通信是实现系统协作和同步的关键。下面将详细介绍进程间通信的...
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
最新发布
08-14
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
深度探索：神经网络在图像识别中的革命性应用
08-14
神经网络是一种受人脑结构启发的数学模型，它由大量的节点（或称为“神经元”）相互连接构成。这些节点通常组织成层，包括输入层、隐藏层和输出层。每个神经元可以接收来自前一层的输入，通过某种激活函数处理这些输入，然后将结果传递给下一层的神经元。 神经网络能够通过学习大量的数据来识别模式和特征，这使得它们在图像识别、语音识别、自然语言处理等领域有着广泛的应用。它们也可以用于预测、分类和回归等任务。 训练神经网络通常涉及到一个称为“反向传播”的过程，通过这个过程，网络可以调整其内部参数（权重和偏置），以便更好地完成特定的任务。这个过程通常需要大量的计算资源，并且伴随着梯度下降或其他优化算法来最小化损失函数，从而提高模型的性能。 随着深度学习技术的发展，神经网络变得更加复杂和强大，出现了各种类型的网络结构，比如卷积神经网络（CNNs）用于图像处理，循环神经网络（RNNs）用于序列数据，以及长短期记忆网络（LSTMs）等。
基础会计教学课件第十一章财务会计报告.pptx
08-14
基础会计教学课件第十一章财务会计报告.pptx
基于Android网络聊天软件APP设计与实现.docx
08-14
基于Android网络聊天软件APP设计与实现.docx
基于Android音乐播放器设计与实现2.docx
08-14
基于Android音乐播放器设计与实现2.docx
深度学习基础：理解神经网络及其应用.md
08-14
深度学习基础中的神经网络原理及其广泛应用。文章首先介绍了神经网络的基本构造、激活函数、反向传播等核心概念，详细讲解了卷积神经网络（CNN）、循环神经网络（RNN）等常见神经网络模型的特点及应用场景。接着，文章展示了神经网络在语音识别、图像识别、自动驾驶、医疗影像分析、金融分析、推荐系统等领域的成功案例。此外，还讨论了深度学习的发展趋势，如更深层次的网络、自监督学习、模型压缩、多模态学习及其在实际应用中的挑战与局限性。文章特别提到神经网络对数据的高度依赖、训练中的计算成本、模型的可解释性问题以及泛化能力不足等技术难点。总体上，本文为读者提供了一个从基础到应用、从原理到前沿发展的全景视角，强调了深度学习在推动人工智能技术发展的重要性。
员工关系中的法律问题.pptx
08-14
员工关系中的法律问题.pptx
高效记录与整理编程学习笔记工具
08-14
Obsidian 是一个以 Markdown 为基础的笔记软件，支持双向链接和知识图谱，非常适合建立个人知识网络。Obsidian 的社区中有很多中文用户，而且可以下载中文插件实现中文界面。
螺旋矩阵算法.txt 基于一维数组与vector完成二级索引优化
08-14
00 01 02 03 04 05 06 07 08 09 00 01 02 03 04 05 06 07 08 09 35 00 00 00 00 00 00 00 00 10 35 36 37 38 39 40 41 42 43 10 34 00 00 00 00 00 00 00 00 11 34 63 64 65 66 67 68 69 44 11 33 00 00 00 00 00 00 00 00 12 33 62 83 84 85 86 87 70 45 12 32 00 00 00 00 00 00 00 00 13 32 61 82 95 96 97 88 71 46 13 31 00 00 00 00 00 00 00 00 14 ...... 31 60 81 94 99 9
openvswitch
08-14
openvswitch
ssm_126_mysql_实习支教中小学学校信息管理系统_.zip
08-14
本系统的后台语言使用的是JSP，JSP是一种动态编程语言，可以对数据进行增删改查等操作。在JSP、ASP、PHP等动态语言出现之前，很多网站就只能用静态的HTML语言宣传自己的网站，但这种网站不具备数据的存储操作功能，因为无法连接数据库，本系统使用的JSP语言可以与HTML语言有效的结合起来，不仅可以将各类素材展现在页面上，还可以将数据保存在数据库中。 选择JSP技术开发主要因为其有以下几个优点： （1）首先就是因为JSP的结构清晰、易于理解，而且JSP是面向对象的编程语言，可以使用封装、继承和多态等技术，可以使用类和对象的思想解决很多问题，可以极大的提高编码效率。 （2）选择JSP的第二个原因就是它在浏览器中的响应速度较快，可以提高本系统运行的速度。 （3）选择JSP作为本系统开发技术的第三个原因就是它具备较为稳定的连接数据库的方法，可以使数据稳定地进行存储和更新。
通用的C++数据结构代码实现，使用模板 代码完整，注释齐全，可直接运行，可使用doxygen生成网页和PDF文档
08-14
通用于各类数据结构与算法(C++语言)教材，适用于自学、课程设计/毕业设计和考研复习等。完整的代码实现，可直接运行调试，使用模板，方便灵活。代码注释完整，可生成网页版/PDF文档，效果丰富
Linux进程间通信机制详解
"Linux进程间通信的PPT，涵盖了进程间通信概述、管道通信、信号、共享内存和消息队列等内容，介绍了多种Unix和System V进程间通信方式以及POSIX标准的通信机制。" 在计算机系统中，进程间通信（Inter-Process ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值