多线程同步

1.多线程并发

1).多线程并发引例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <pthread.h>int wg=0;
void *fun(void *arg)
{for(int i=0;i<1000;i++){wg++;printf("wg=%d\n",wg);}
}
int main()
{pthread_t id[5];for(int i=0;i<5;i++){pthread_create(&id[i],NULL,fun,NULL);}for(int i=0;i<5;i++){pthread_join(id[i],NULL);}exit(0);
}

思考运行结果?为什么?
原子操作的概念:一个或多个指令的序列,对外是不可分的;即没有其他进程可以看到其中间状态或者中断此操作;
而wg++不是一个原子操作;
这种情况也不是每一次都发生,也不是一定发生了多少次.这种情况就是最可怕的,给人的感觉是时对时错;
注意,只有一个处理器的时候这种情况出现的概率是非常小的,同一时刻只有一个线程在运行,不容易出现两个线程同时去获取i的值的情况,但是也会发生;

2).解决多线程并发---线程同步

多线程并发就有可能出现问题的,比如两个线程都去在链表中插入,比如都在做尾插,都在找尾巴,那么多线程就会出问题; 怎么解决这个问题呢?就是线程同步;

image-20231018203308218.png


在一个多线程程序里,默认情况下,只有一个errno变量供所有的线程共享.在一个线程准备获取刚才的错误代码时,该变量很容易被另一个线程中的函数调用所改变.

2.线程同步的概念:

一个进程中的所有线程共享同一个地址空间和诸如打开的文件之类的其他资源.一个线程对资源的任何修改都会影响同一个进程中其他线程的环境.因此,需要同步各种线程的活动,以便它们互不干涉且不破坏数据结构.例如,如果两个线程都试图同时往一个双向链表中增加一个元素,则可能会丢失一个元素或者破坏链表结构.
同步就是让所有线程按照一定的规则执行,使得其正确性和效率都有迹可循.线程同步的手段就是对线程之间的穿插进行控制.
线程同步指的是当一个线程在对某个临界资源进行操作时，其他线程都不可以对这个资源进行操作，直到该线程完成操作， 其他线程才能操作，也就是协同步调，让线程按预定的先后次序进行运行。

临界资源:同一时刻,只允许被一个进程或者线程访问的资源;(比如打印机)
临界区:访问临界资源的代码段;
线程同步的方法有四种：互斥锁、信号量、条件变量、读写锁.

3.互斥锁:线程同步方法一

(1)互斥锁接口
int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr);
attr:锁的属性,不需要传空即可int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex);int pthread_mutex_destroy(pthread_mutex_t *mutex);   
//注意,互斥锁mutex都需要传地址,因为要改变它;
(2)互斥锁例1(解决多线程并发问题)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <pthread.h>pthread_mutex_t  mutex;
int wg=0;
void *fun(void *arg)
{for(int i=0;i<1000;i++){pthread_mutex_lock(&mutex);wg++;pthread_mutex_unlock(&mutex);printf("wg=%d\n",wg);}
}
int main()
{pthread_t id[5];pthread_mutex_init(&mutex,NULL);for(int i=0;i<5;i++){pthread_create(&id[i],NULL,fun,NULL);}for(int i=0;i<5;i++){pthread_join(id[i],NULL);}pthread_mutex_destroy(&mutex);exit(0);
}
(3)互斥锁例2(共享资源(打印机)使用问题)

主线程和函数线程模拟访问打印机，主线程输出第一个字符‘ A’表示开始使用打印机，输出第二个字符‘ A’表示结束使用，函数线程操作与主线程相同。 （由于打印机同一时刻只能被一个线程使用，所以输出结果不应该出现ABAB交替出现） ： 原来是用信号量进行控制的,我们这里也可以用互斥锁进行同步;

示例代码:


#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>pthread_mutex_t mutex;void *thread_fun(void *arg)
{int i=0;for(;i<5;i++){pthread_mutex_lock(&mutex);write(1,"B",1);int n=rand()%3;sleep(n);write(1,"B",1);pthread_mutex_unlock(&mutex);n=rand()%3;sleep(n);}pthread_exit(NULL);
}int main()
{pthread_t id;pthread_mutex_init(&mutex,NULL);pthread_create(&id,NULL,thread_fun,NULL);int i=0;for(;i<5;i++){pthread_mutex_lock(&mutex);write(1,"A",1);int n=rand()%3;sleep(n);write(1,"A",1);pthread_mutex_unlock(&mutex);n=rand()%3;sleep(n);}pthread_join(id,NULL);pthread_mutex_destroy(&mutex);exit(0);
}

4.信号量(线程)线程同步方法二

(1)信号量接口
信号量的类型:
sem_t  全局定义一个sem_t类型的信号量
注意,必须要加头文件:#include <semaphore.h>int sem_init(sem_t *sem, int pshared, unsigned int value);
//信号量的初始化
//sem_init（）在sem指向的地址初始化未命名的信号量。这个value参数指定信号量的初始值(第三个参数)。
//pshared:设置信号量是否在进程间共享,Linux不支持,一般给0; (非0为共享)int sem_wait(sem_t *sem);
//P操作,wait表示等待,相当于是等待获取资源,那么就是P操作int sem_post(sem_t *sem);
//V操作int sem_destroy(sem_t *sem);  
//销毁信号量
(2)信号量例1(全局变量++正确性问题)

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <pthread.h>sem_t sem;
int wg=0;
void *fun(void *arg)
{for(int i=0;i<1000;i++){sem_wait(&sem);wg++;sem_post(&sem);printf("wg=%d\n",wg);}
}
int main()
{pthread_t id[5];sem_init(&sem,0,1);for(int i=0;i<5;i++){pthread_create(&id[i],NULL,fun,NULL);}for(int i=0;i<5;i++){pthread_join(id[i],NULL);}sem_destroy(&sem);exit(0);
}
(3)信号量例2

主线程获取用户输入,函数线程将用户输入的数据存储到文件中;

//semtest.c
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include <fcntl.h>char buff[128]={0};
//主线程完成获取用户数据的数据,并存储在全局数组buff中;sem_t sem1;
sem_t sem2;void *PthreadFun(void *arg)
{int fd=open("a.txt",O_RDWR|O_CREAT,0664);//O_RDWR:读写方式打开assert(fd!=-1);//函数线程完成将用户输入的数据存储到文件中while(1){sem_wait(&sem2);if(strncmp(buff,"end",3)==0){break;}write(fd,buff,strlen(buff));memset(buff,0,128);sem_post(&sem1);}sem_destroy(&sem1);sem_destroy(&sem2);
}int main()
{sem_init(&sem1,0,1);sem_init(&sem2,0,0);pthread_t id;int res=pthread_create(&id,NULL,PthreadFun,NULL);assert(res==0);//主线程完成获取用户数据的数据,并存储在全局数组buff中;while(1){sem_wait(&sem1);printf("please input data:");fflush(stdout);fgets(buff,128,stdin);buff[strlen(buff)-1]=0;sem_post(&sem2);if(strncmp(buff,"end",3)==0){break;}}pthread_exit(NULL);
}

(4)信号量例3

(以前是用多进程做的,封装比较麻烦.那如果用多线程的信号量做,如何做呢)
刚开始先打印A,所以信号量为1,后面的B和C不能打印,所以后面两个信号量的初始值都为0;

image-20231022224850037.png



上面是多进程的思路图,多线程的思路和多进程是一样的.
不使用信号量,代码如下:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>void * funa(void *arg)
{for(int i=0;i<5;i++){printf("A");fflush(stdout);sleep(1);//这个其实不需要的,只是为了便于观察程序的执行;}
}void * funb(void *arg)
{for(int i=0;i<5;i++){printf("B");fflush(stdout);sleep(1);//这个其实不需要的,只是为了便于观察程序的执行;}
}void * func(void *arg)
{for(int i=0;i<5;i++){printf("C");fflush(stdout);sleep(1);//这个其实不需要的,只是为了便于观察程序的执行;}
}int main()
{pthread_t id[3];pthread_create(&id[0],NULL,funa,NULL);pthread_create(&id[1],NULL,funb,NULL);pthread_create(&id[2],NULL,func,NULL);for(int i=0;i<3;i++){pthread_join(id[i],NULL);}exit(0);}

那么,
如何使用信号量呢?

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>//加入1-15 代码
sem_t sema;//1
sem_t semb;//2
sem_t semc;//3void * funa(void *arg)
{for(int i=0;i<5;i++){sem_wait(&sema);//4相当于图上的ps1;printf("A");fflush(stdout);sem_post(&semb);//5相当于图上的vs2;sleep(1);//这个其实不需要的,只是为了便于观察程序的执行;}
}void * funb(void *arg)
{for(int i=0;i<5;i++){sem_wait(&semb);//6相当于图上的ps2;printf("B");fflush(stdout);sem_post(&semc);//7相当于图上的vs3;sleep(1);//这个其实不需要的,只是为了便于观察程序的执行;}
}void * func(void *arg)
{for(int i=0;i<5;i++){sem_wait(&semc);//8相当于图上的ps3;printf("C");fflush(stdout);sem_post(&sema);//9相当于图上的vs1;sleep(1);//这个其实不需要的,只是为了便于观察程序的执行;}
}int main()
{sem_init(&sema,0,1);//10也可以这么理解,第二个参数一直为0,因为不能在进程间共享;sem_init(&semb,0,0);//11sem_init(&semc,0,0);//12pthread_t id[3];pthread_create(&id[0],NULL,funa,NULL);pthread_create(&id[1],NULL,funb,NULL);pthread_create(&id[2],NULL,func,NULL);for(int i=0;i<3;i++){pthread_join(id[i],NULL);}sem_destroy(&sema);//13sem_destroy(&semb);//14sem_destroy(&semc);//15exit(0);}

5.条件变量：线程同步方法三

(1)条件变量的接口:
#include <pthread.h>int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr);int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
//将条件变量添加到等待队列中,阻塞,等待被唤醒;第一个参数是条件变量的地址,第二个参数是互斥锁;也就是说条件变量往往伴随着互斥锁的使用;int pthread_cond_signal(pthread_cond_t *cond); //唤醒单个线程int pthread_cond_broadcast(pthread_cond_t *cond); //唤醒所有等待的线程int pthread_cond_destroy(pthread_cond_t *cond);//销毁条件变量
(2)例题:

主函数输入数据到全局变量buf中.
主线程负责从键盘获取数据,获取到数据之后把数据写入到buff中,我们就认为条件满足了,我们就去唤醒等待着的两个线程,让其中的某一个线程将buff中的数据打印出去;

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>pthread_cond_t cond;
pthread_mutex_t mutex;//条件变量一般伴随着互斥锁的使用;char buff[128]={0};void *work_thread(void *arg)
{char *thread_name=(char *)arg;while(1){pthread_mutex_lock(&mutex);pthread_cond_wait(&cond,&mutex);pthread_mutex_unlock(&mutex);if(strncmp(buff,"end",3)==0){break;//1}printf("%s  %s",thread_name,buff);//2}
}int main()
{pthread_cond_init(&cond,NULL);pthread_mutex_init(&mutex,NULL);pthread_t id1,id2;pthread_create(&id1,NULL,work_thread,"thread:1");pthread_create(&id2,NULL,work_thread,"thread:2");while(1){fgets(buff,128,stdin);if(strncmp(buff,"end",3)==0){pthread_cond_broadcast(&cond);break;}else{pthread_cond_signal(&cond);}}pthread_join(id1,NULL);pthread_join(id2,NULL);pthread_mutex_destroy(&mutex);pthread_cond_destroy(&cond);printf("main over\n");exit(0);
}

pthread_cond_broadcast函数以广播的方式唤醒所有等待目标条件变量的线程;
pthread_cond_signal函数用于唤醒一个等待目标条件变量的线程.至于哪个线程将被唤醒,则取决于线程的优先级和调度策略.有时候我们可能想唤醒一个指定的线程,但是pthread没有对该需求提供解决方法.

pthread_cond_wait函数用于等待目标条件变量.mutex参数是用于保护条件变量的互斥锁,以确保pthread_conde_wait操作的原子性.在调用pthread_cond_wait前,必须确保互斥锁mutex已经加锁,否则将导致不可预期的结果.pthread_cond_wait函数执行时,首先把调用线程放入条件变量的等待队列中,然后将互斥锁mutex解锁.可见,从pthread_cond_wait开始执行到其调用线程被放入条件变量的等待队列之间的这段时间内,pthread_cond_signal和pthread_cond_broadcast等函数不会修改条件变量.换言之,pthread_cond_wait函数不会错过目标条件变量的任何变化.当pthread_cond_wait函数成功返回时,互斥锁mutex将再次被锁上.

6.读写锁:线程同步方法四

读写锁保证了更高的并发性;
读写锁适用读的场景比较多的场景;

(1)读写锁的接口
#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *rwlock, pthread_rwlockattr_t *attr);//第一个参数是锁的地址,第二个参数是锁的属性
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);//加读锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);//加写锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);//解锁,不管加的读锁还是写锁,都是通过unlock解锁;
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);//销毁  //读模式下的加锁状态,写模式下的加锁状态,不加锁的状态
(2)例题：

///模拟 //我们可以创建3个线程,两个线程进行读操作,一个线程进行写操作; //我们模拟一下这个,可以让两个读操作同时操作;但是读和写是不能同时操作的;

我们首先来看没有控制的代码:


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>pthread_rwlock_t rwlock;
void * fun_read(void * arg)
{char *s=(char *)arg;for(int i=0;i<5;i++){printf("%s:  start\n",s);int n=rand()%3;sleep(n);printf("%s:  end\n",s);n=rand()%3;sleep(n);}
}void * fun_write(void * arg)
{char *s=(char *)arg;for(int i=0;i<5;i++){printf("%s:  start\n",s);int n=rand()%3;sleep(n);printf("%s:  end\n",s);n=rand()%3;sleep(n);}
}int main()
{pthread_rwlock_init(&rwlock,NULL);pthread_t id1,id2,id3;pthread_create(&id1,NULL,fun_read,"第一个读线程:");pthread_create(&id2,NULL,fun_read,"第二个读线程:");pthread_create(&id3,NULL,fun_write,"第一个写线程:");pthread_join(id1,NULL);pthread_join(id2,NULL);pthread_join(id3,NULL);pthread_rwlock_destroy(&rwlock);exit(0);}

如何运用读写锁呢?代码如下:


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>pthread_rwlock_t rwlock;
void * fun_read(void * arg)
{char *s=(char *)arg;for(int i=0;i<5;i++){pthread_rwlock_rdlock(&rwlock);//1pthread_rwlock_rdlock命名含有:线程的_读写锁_读锁;printf("%s:  start\n",s);int n=rand()%3;sleep(n);printf("%s:  end\n",s);pthread_rwlock_unlock(&rwlock);//2pthread_rwlock_unlock命名含有:线程的_读写锁_解锁;n=rand()%3;sleep(n);}
}void * fun_write(void * arg)
{char *s=(char *)arg;for(int i=0;i<5;i++){pthread_rwlock_wrlock(&rwlock);//3pthread_rwlock_rwlock命名含有:线程的_读写锁_写锁;printf("%s:  start\n",s);int n=rand()%3;sleep(n);printf("%s:  end\n",s);pthread_rwlock_unlock(&rwlock);//4pthread_rwlock_unlock命名含有:线程的_读写锁_解锁;n=rand()%3;sleep(n);}
}int main()
{pthread_rwlock_init(&rwlock,NULL);pthread_t id1,id2,id3;pthread_create(&id1,NULL,fun_read,"r1");pthread_create(&id2,NULL,fun_read,"r2");pthread_create(&id3,NULL,fun_write,"w1");pthread_join(id1,NULL);pthread_join(id2,NULL);pthread_join(id3,NULL);pthread_rwlock_destroy(&rwlock);exit(0);}

我们要保证写的start和end直接是不能出现读的,而且读两个可以,读的中间不能有写;

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/5156.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

tp6.0 rabbitmq死信队列

tp6.0 rabbitmq死信队列

rabbitMq交换机&#xff0c;队列情况&#xff0c;先手动创建 1. 创建普通交换机exchange&#xff0c;普通队列order_queue_expire&#xff0c;队列设置属性&#xff1a; 消息过期时间&#xff1a;60000毫秒&#xff0c;过期绑定dead_exchange交换机&#xff0c;routing_key:de…
阅读更多...
适配器模式（不同类型的 MQ 消息 首次下单消息）

适配器模式（不同类型的 MQ 消息 首次下单消息）

目录 定义 适配不同类型的 MQ 消息 注册开户MQ 内部订单MQ 第三⽅订单MQ 查询⽤户内部下单数量接⼝ 查询⽤户第三⽅下单⾸单接⼝ MQ消息体适配类 代码实现 测试验证 接⼝使⽤适配 代码实现 分别实现两个不同的接⼝ 内部商品接⼝ 第三⽅商品接⼝ 测试验证 定义 …
阅读更多...
使用递归方式实现多级菜单树 Java实现

使用递归方式实现多级菜单树 Java实现

在Java中&#xff0c;使用递归来实现菜单树通常涉及到遍历原始菜单列表&#xff0c;并为每个菜单项找到其对应的子菜单项。这个过程可以通过创建一个方法来完成&#xff0c;该方法会检查每个菜单项的parentId&#xff0c;并将其作为子菜单项添加到具有相应id的父菜单项的childr…
阅读更多...
web前端学习笔记2

web前端学习笔记2

2. 网页穿上美丽外衣 2.0 代码地址 https://gitee.com/qiangge95243611/java118/tree/master/web/day02 2.1 什么是CSS CSS (Cascading Style Sheets，层叠样式表），是一种用来为结构化文档（如 HTML 文档或 XML 应用）添加样式（字体、间距和颜色等）的计算机语言，CSS 文…
阅读更多...
docker学习笔记7：centos docker安装mysql

docker学习笔记7：centos docker安装mysql

在 CentOS 系统上使用 Docker 安装 MySQL 8 的过程相对简单。以下是一步步的指导： 1. 确保 Docker 已经安装 首先，你需要确保你的 CentOS 系统上已经安装了 Docker。可以通过以下命令检查 Docker 是否已经安装并且运行： sudo systemctl status docker如果 Docker 没有安装…
阅读更多...
文件系统学习

文件系统学习

软连接&#xff1a;可以跨不同的磁盘块&#xff0c;创建出不同的inode节点 应连接&#xff1a;相同的inode节点&#xff0c;不同的文件名字记录在父亲节点目录中 分区(fdisk)&#xff0c;格式化(mkfs)&#xff0c;挂载(mount)&#xff0c;大于2T分区&#xff08;parted&#…
阅读更多...
FSNotes for Mac v6.7.1中文激活版：强大的笔记管理工具

FSNotes for Mac v6.7.1中文激活版：强大的笔记管理工具

FSNotes for Mac是一款功能强大的文本处理与笔记管理工具&#xff0c;为Mac用户提供了一个直观、高效的笔记记录和整理平台。 FSNotes for Mac v6.7.1中文激活版下载 FSNotes支持Markdown语法&#xff0c;使用户能够轻松设置笔记格式并添加链接、图像等元素&#xff0c;实现笔记…
阅读更多...
前端调用WebSocket协议接口获取数据

前端调用WebSocket协议接口获取数据

目录 封装调用ws协议接口工具函数 页面调用 封装调用ws协议接口工具函数 params&#xff1a;请求参数cb&#xff1a;服务器请求成功返回数据的回调函数 function createWs(params, cb) {const ws new WebSocket("ws://124.222.224.186:8800");let timer null;// …
阅读更多...
基于H.264的RTP打包中的组合封包以及分片封包结构图简介及抓包分析；FU-A FU-B STAP-A STAP-B简介；

基于H.264的RTP打包中的组合封包以及分片封包结构图简介及抓包分析；FU-A FU-B STAP-A STAP-B简介；

H.264视频流的RTP封装类型分析&#xff1a; 前言&#xff1a; 1.RTP打包原则&#xff1a; RTP的包长度必须要小于MTU(最大传输单元)&#xff0c;IP协议中MTU的最大长度为1500字节。除去IP报头&#xff08;20字节&#xff09;、UDP报头&#xff08;8字节&#xff09;、RTP头&a…
阅读更多...
C#编程模式之装饰模式

C#编程模式之装饰模式

创作背景&#xff1a;朋友们&#xff0c;我们继续C#编程模式的学习&#xff0c;本文我们将一起探讨装饰模式。装饰模式也是一种结构型设计模式&#xff0c;它允许你通过在运行时向对象添加额外的功能&#xff0c;从而动态的修改对象的行为。装饰模式本质上还是继承的一种替换方…
阅读更多...
机器学习-什么是 k-means？

机器学习-什么是 k-means？

1、什么是 k-means&#xff1f; k-means是一种无监督的分类学习算法。它的基本原理是以距离作为相似度的评价指标&#xff0c;用样本点到类别中心的误差平方和作为聚类好坏的评价指标&#xff0c;通过迭代的方法使总体分类的误差评分和函数达到最小的聚类方法。 2、 k-means聚…
阅读更多...
设计模式 基本认识

设计模式 基本认识

文章目录 设计模式的作用设计模式三原则设计模式与类图设计模式的分类 设计模式的作用 设计模式是在软件设计过程中针对常见问题的解决方案的一种通用、可重用的解决方案。设计模式提供了一种经过验证的方法&#xff0c;可以帮助开发人员解决特定类型的问题&#xff0c;并在软…
阅读更多...
【论文阅读】IPT:Pre-TrainedImageProcessingTransformer

【论文阅读】IPT:Pre-TrainedImageProcessingTransformer

Pre-TrainedImageProcessingTransformer 论文地址摘要1. 简介2.相关作品2.1。图像处理2.2。 Transformer 3. 图像处理3.1. IPT 架构3.2 在 ImageNet 上进行预训练 4. 实验4.1. 超分辨率4.2. Denoising 5. 结论与讨论 论文地址 1、论文地址 2、源码 摘要 随着现代硬件的计算能…
阅读更多...
1394 笔记

1394 笔记

RN节点工作模块&#xff0c;当接收到STOF包后开始计时&#xff0c;当达到节点的发送、接收、数据泵偏移时向应用层发送相应使能。并根据STOF判断CC的错误状态&#xff0c;只有以下条件全部满足时进入正常工作模式&#xff1a; 条件1&#xff0c;STOF消息的帧周期正确&#xff…
阅读更多...
mybatis工程需要的pom.xml，以及@Data 、@BeforeEach、@AfterEach 的使用，简化mybatis

mybatis工程需要的pom.xml，以及@Data 、@BeforeEach、@AfterEach 的使用，简化mybatis

对 “mybatis - XxxMapper.java接口中方法的参数 和 返回值类型&#xff0c;怎样在 XxxMapper.xml 中配置的问题” 这篇文章做一下优化 这个pom.xml文件&#xff0c;就是上面说的这篇文章的父工程的pom.xml&#xff0c;即&#xff1a;下面这个pom.xml 是可以拿来就用的 <?…
阅读更多...
7天入门Android开发之第1天——初识Android

7天入门Android开发之第1天——初识Android

一、Android系统 1.Linux内核层&#xff1a; 这是安卓系统的底层&#xff0c;它提供了基本的系统功能&#xff0c;如内存管理、进程管理、驱动程序模型等。安卓系统构建在Linux内核之上&#xff0c;借助于Linux的稳定性和安全性。 2.系统运行库层&#xff1a; 这一层包括了安卓…
阅读更多...
Java高级面试问题及答案

Java高级面试问题及答案

Java高级面试问题及答案 1. 什么是Java中的多态性&#xff1f;如何实现多态性&#xff1f; 问题描述&#xff1a; 多态性是面向对象编程的重要概念之一&#xff0c;它允许不同类的对象对同一消息做出不同的响应。请简要说明Java中的多态性&#xff0c;并描述如何实现多态性。…
阅读更多...
短剧小程序开发，为什么短剧市场越来越火爆？

短剧小程序开发，为什么短剧市场越来越火爆？

大众眼帘&#xff0c;但是不可否认现在短剧的质量也处在一个不断上升的阶段&#xff0c;我们今天就来分析分析短剧市场兴起的原因吧&#xff5e; 一、大趋势大环境的影响下&#xff0c;很多新型行业诞生&#xff0c;多数行业都在精进变化和改革&#xff0c;淘汰旧思想&#xf…
阅读更多...
MYSQL 8.0的Linux - Generic版本安装

MYSQL 8.0的Linux - Generic版本安装

1.本文适用范围 适用于MYSQL 8.0的Linux - Generic版本&#xff0c;原则上适用所有的操作系统。已测试的操作系统包括&#xff1a; Ubuntu 16.04Ubuntu 18.04Ubuntu 20.04Ubuntu 22.04Kylin Linux Advanced Server V10 ​ 注意&#xff1a;如果操作系统使用过包管理系统&…
阅读更多...
深入理解Java消息中间件-使用Spring Framework进行消息驱动的开发

深入理解Java消息中间件-使用Spring Framework进行消息驱动的开发

结合Spring Framework&#xff0c;特别是Spring for Apache Kafka项目&#xff0c;Java开发者可以更加便捷高效地实现Kafka的生产者和消费者应用。本文将详细介绍如何在Spring环境中开发Kafka应用&#xff0c;确保内容的准确性并避免技术误导。 环境准备 首先&#xff0c;确保您…
阅读更多...
最新文章

Copyright @ 2022~2023