百度360必应搜狗淘宝本站头条
python类型转换python串口编程python计时python异常python进度条
当前位置：网站首页 > 技术资源 > 正文

Linux C++实现多线程同步的四种方式(超级详细)

off999 2025-03-03 19:43 34 浏览 0 评论

背景问题：在特定的应用场景下，多线程不进行同步会造成什么问题？

通过多线程模拟多窗口售票为例：

#include

#include

#include

#include

#include

#include

using namespace std;

int ticket_sum=20;

void *sell_ticket(void *arg)

{

for(int i=0; i<20; i++)

{

if(ticket_sum>0)

{

sleep(1);

cout<<"sell the "<<20-ticket_sum+1<<"th"<

ticket_sum--;

}

}

return 0;

}

int main()

{

int flag;

pthread_t tids[4];

for(int i=0; i<4; i++)

{

flag=pthread_create(&tids[i],NULL,&sell_ticket,NULL);

if(flag)

{

cout<<"pthread create error ,flag="<

return flag;

}

}

sleep(20);

void *ans;

for(int i=0; i<4; i++)

{

flag=pthread_join(tids[i],&ans);

if(flag)

{

cout<<"tid="<return flag;

}

cout<<"ans="<

}

return 0;

}


分析：总票数只有20张，却卖出了23张，是非常明显的超买超卖问题，而造成这个问题的根本原因就是同时发生的各个线程都可以对ticket_sum进行读取和写入！

ps：

1.在并发情况下，指令执行的先后顺序由内核决定，同一个线程内部，指令按照先后顺序执行，但不同线程之间的指令很难说清楚是哪一个先执行，如果运行的结果依赖于不同线程执行的先后的话，那么就会形成竞争条件，在这样的情况下，计算的结果很难预知，所以应该尽量避免竞争条件的形成

2.最常见的解决竞争条件的方法是将原先分离的两个指令构成一个不可分割的原子操作，而其他任务不能插入到原子操作中！

3.对多线程来说，同步指的是在一定时间内只允许某一个线程访问某个资源，而在此时间内，不允许其他线程访问该资源!

4.线程同步的常见方法：互斥锁，条件变量，读写锁，信号量

一.互斥锁

本质就是一个特殊的全局变量，拥有lock和unlock两种状态，unlock的互斥锁可以由某个线程获得，一旦获得，这个互斥锁会锁上变成lock状态，此后只有该线程由权力打开该锁，其他线程想要获得互斥锁，必须得到互斥锁再次被打开之后

采用互斥锁来同步资源:

#include

#include

#include

#include

#include

#include

using namespace std;

int ticket_sum=20;

pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER;//static init mutex

void *sell_ticket(void *arg)

{

for(int i=0; i<20; i++)

{

pthread_mutex_lock(&mutex_x);//atomic opreation through mutex lock

if(ticket_sum>0)

{

sleep(1);

cout<<"sell the "<<20-ticket_sum+1<<"th"<

ticket_sum--;

}

pthread_mutex_unlock(&mutex_x);

}

return 0;

}

int main()

{

int flag;

pthread_t tids[4];

for(int i=0; i<4; i++)

{

flag=pthread_create(&tids[i],NULL,&sell_ticket,NULL);

if(flag)

{

cout<<"pthread create error ,flag="<

return flag;

}

}

sleep(20);

void *ans;

for(int i=0; i<4; i++)

{

flag=pthread_join(tids[i],&ans);

if(flag)

{

cout<<"tid="<return flag;

}

cout<<"ans="<

}

return 0;

}

分析：通过为售票的核心代码段加互斥锁使得其变成了一个原子性操作！不会被其他线程影响

1.互斥锁的初始化

互斥锁的初始化分为静态初始化和动态初始化

静态：pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER;//static init mutex

动态：pthread_mutex_init函数

ps：互斥锁静态初始化和动态初始化的区别？

待补充。。。。

2.互斥锁的相关属性及分类

//初始化互斥锁属性

pthread_mutexattr_init(pthread_mutexattr_t attr);

//销毁互斥锁属性

pthread_mutexattr_destroy(pthread_mutexattr_t attr);

//用于获取互斥锁属性

int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict attr , int *restrict pshared);

//用于设置互斥锁属性

int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr , int pshared);

attr表示互斥锁的属性

pshared表示互斥锁的共享属性，由两种取值：

1）PTHREAD_PROCESS_PRIVATE：锁只能用于一个进程内部的两个线程进行互斥（默认情况）

2）PTHREAD_PROCESS_SHARED：锁可用于两个不同进程中的线程进行互斥，使用时还需要在进程共享内存中分配互斥锁，然后为该互斥锁指定属性就可以了

互斥锁的分类：

//获取互斥锁类型

int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr , int *restrict type);

//设置互斥锁类型

int pthread_mutexattr_settype(const pthread_mutexattr_t *restrict attr , int type);

参数type表示互斥锁的类型，总共有以下四种类型：

1.PTHREAD_MUTEX_NOMAL:标准互斥锁，第一次上锁成功，第二次上锁会失败并阻塞


2.PTHREAD_MUTEX_RECURSIVE:递归互斥锁，第一次上锁成功，第二次上锁还是会成功，可以理解为内部有一个计数器，每加一次锁计数器加1，解锁减1


3.PTHREAD_MUTEX_ERRORCHECK:检查互斥锁，第一次上锁会成功，第二次上锁出错返回错误信息，不会阻塞

4.PTHREAD_MUTEX_DEFAULT:默认互斥锁，第一次上锁会成功，第二次上锁会失败

3，测试加锁函数

int pthread_mutex_lock(&mutex):测试加锁函数在锁已经被占据时返回EBUSY而不是挂起等待，当然，如果锁没有被占领的话可以获得锁

为了清楚的看到两个线程争用资源的情况，我们使得其中一个函数使用测试加锁函数进行加锁，而另外一个使用正常的加锁函数进行加锁

#include

#include

#include

#include

#include

#include

#include

using namespace std;

int ticket_sum=20;

pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER;//static init mutex

void *sell_ticket_1(void *arg)

{

for(int i=0; i<20; i++)

{

pthread_mutex_lock(&mutex_x);

if(ticket_sum>0)

{

sleep(1);

cout<<"thread_1 sell the "<<20-ticket_sum+1<<"th ticket"<

ticket_sum--;

}

sleep(1);

pthread_mutex_unlock(&mutex_x);

sleep(1);

}

return 0;

}

void *sell_ticket_2(void *arg)

{

int flag;

for(int i=0; i<10; i++)

{

flag=pthread_mutex_trylock(&mutex_x);

if(flag==EBUSY)

{

cout<<"sell_ticket_2:the variable is locked by sell_ticket_1"<

}

else if(flag==0)

{

if(ticket_sum>0)

{

sleep(1);

cout<<"thread_2 sell the "<<20-ticket_sum+1<<"th tickets"<

ticket_sum--;

}

pthread_mutex_unlock(&mutex_x);

}

sleep(1);

}

return 0;

}

int main()

{

int flag;

pthread_t tids[2];

flag=pthread_create(&tids[0],NULL,&sell_ticket_1,NULL);

if(flag)

{

cout<<"pthread create error ,flag="<

return flag;

}

flag=pthread_create(&tids[1],NULL,&sell_ticket_2,NULL);

if(flag)

{

cout<<"pthread create error ,flag="<

return flag;

}

void *ans;

sleep(30);

flag=pthread_join(tids[0],&ans);

if(flag)

{

cout<<"tid="<return flag;

}

else

{

cout<<"ans="<

}

flag=pthread_join(tids[1],&ans);

if(flag)

{

cout<<"tid="<return flag;

}

else

{

cout<<"ans="<

}

return 0;

}


分析：通过测试加锁函数我们可以清晰的看到两个线程争用资源的情况

二.条件变量

互斥量不是万能的，比如某个线程正在等待共享数据内某个条件出现，可可能需要重复对数据对象加锁和解锁（轮询），但是这样轮询非常耗费时间和资源，而且效率非常低，所以互斥锁不太适合这种情况

我们需要这样一种方法：当线程在等待满足某些条件时使线程进入睡眠状态，一旦条件满足，就换线因等待满足特定条件而睡眠的线程

如果我们能够实现这样一种方法，程序的效率无疑会大大提高，而这种方法正是条件变量！

样例：

#include

#include

#include

#include

#include

#include

#include

using namespace std;

pthread_cond_t qready=PTHREAD_COND_INITIALIZER; //cond

pthread_mutex_t qlock=PTHREAD_MUTEX_INITIALIZER; //mutex

int x=10,y=20;

void *f1(void *arg)

{

cout<<"f1 start"<

pthread_mutex_lock(&qlock);

while(x

{

pthread_cond_wait(&qready,&qlock);

}

pthread_mutex_unlock(&qlock);

sleep(3);

cout<<"f1 end"<

return 0;

}

void *f2(void *arg)

{

cout<<"f2 start"<

pthread_mutex_lock(&qlock);

x=20;

y=10;

cout<<"has a change,x="<pthread_mutex_unlock(&qlock);

if(x>y)

{

pthread_cond_signal(&qready);

}

cout<<"f2 end"<

return 0;

}

int main()

{

pthread_t tids[2];

int flag;

flag=pthread_create(&tids[0],NULL,f1,NULL);

if(flag)

{

cout<<"pthread 1 create error "<

return flag;

}

sleep(2);

flag=pthread_create(&tids[1],NULL,f2,NULL);

if(flag)

{

cout<<"pthread 2 create erro "<

return flag;

}

sleep(5);

return 0;

}


分析：线程1不满足条件被阻塞，然后线程2运行，改变了条件，线程2发行条件改变了通知线程1运行，然线程1不满足条件被阻塞，然后线程2运行，改变了条件，线程2发行条件改变了通知线程1运行，然后线程2结束，然后线程1继续运行，然后线程1结束，为了确保线程1先执行，在创建线程2之前我们sleep了2秒

ps：

1.条件变量通过运行线程阻塞和等待另一个线程发送信号的方法弥补互斥锁的不足，常常和互斥锁一起使用，使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开响应的互斥锁并等待条件发生变化，一旦其他的某个线程改变了条件变量，它将通知响应的条件变量换线一个或多个正被此条件变量阻塞的线程，这些线程将重新锁定互斥锁并且重新测试条件是否满足

1.条件变量的相关函数

1）创建

静态方式：pthread_cond_t cond PTHREAD_COND_INITIALIZER

动态方式：int pthread_cond_init(&cond,NULL)

Linux thread 实现的条件变量不支持属性，所以NULL(cond_attr参数）

2）注销

int pthread_cond_destory(&cond)

只有没有线程在该条件变量上，该条件变量才能注销，否则返回EBUSY

因为Linux实现的条件变量没有分配什么资源，所以注销动作只包括检查是否有等待线程!(请参考条件变量的底层实现）

3）等待

条件等待：int pthread_cond_wait(&cond,&mutex)

计时等待：int pthread_cond_timewait(&cond,&mutex,time)

1.其中计时等待如果在给定时刻前条件没有被满足，则返回ETIMEOUT，结束等待

2.无论那种等待方式，都必须有一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait形成竞争条件！

3.在调用pthread_cond_wait前必须由本线程加锁

4）激发

激发一个等待线程：pthread_cond_signal(&cond)

激发所有等待线程：pthread_cond_broadcast(&cond)

重要的是，pthread_cond_signal不会存在惊群效应，也就是是它最多给一个等待线程发信号，不会给所有线程发信号唤醒提他们，然后要求他们自己去争抢资源！

pthread_cond_signal会根据等待线程的优先级和等待时间来确定激发哪一个等待线程

下面看一个程序，找到程序存在的问题

#include

#include

#include

#include

#include

#include

#include

using namespace std;

pthread_cond_t taxi_cond=PTHREAD_COND_INITIALIZER; //taix arrive cond

pthread_mutex_t taxi_mutex=PTHREAD_MUTEX_INITIALIZER;// sync mutex

void *traveler_arrive(void *name)

{

cout<<"Traveler:"<<(char*)name<<" needs a taxi now!"<

pthread_mutex_lock(&taxi_mutex);

pthread_cond_wait(&taxi_cond,&taxi_mutex);

pthread_mutex_unlock(&taxi_mutex);

cout<<"Traveler:"<<(char*)name<<" now got a taxi!"<

pthread_exit((void*)0);

}

void *taxi_arrive(void *name)

{

cout<<"Taxi:"<<(char*)name<<" arriver."<

pthread_cond_signal(&taxi_cond);

pthread_exit((void*)0);

}

int main()

{

pthread_t tids[3];

int flag;

flag=pthread_create(&tids[0],NULL,taxi_arrive,(void*)("Jack"));

if(flag)

{

cout<<"pthread_create error:flag="<

return flag;

}

cout<<"time passing by"<

sleep(1);

flag=pthread_create(&tids[1],NULL,traveler_arrive,(void*)("Susan"));

if(flag)

{

cout<<"pthread_create error:flag="<

return flag;

}

cout<<"time passing by"<

sleep(1);

flag=pthread_create(&tids[2],NULL,taxi_arrive,(void*)("Mike"));

if(flag)

{

cout<<"pthread_create error:flag="<

return flag;

}

cout<<"time passing by"<

sleep(1);

void *ans;

for(int i=0; i<3; i++)

{

flag=pthread_join(tids[i],&ans);

if(flag)

{

cout<<"pthread_join error:flag="<

return flag;

}

cout<<"ans="<

}

return 0;

}


分析：程序由一个条件变量，用于提示乘客有出租车到达，还有一个同步锁，乘客到达之后就是等车（条件变量），出租车到达之后就是通知乘客，我们看到乘客Susan到达之后，并没有乘坐先到的Jack的车，而是等到Mike的车到了之后再乘坐Mike的车，Jack的车白白的闲置了，为什么会造成这种原因呢？分析一下代码：我们发现Jack出租车到达之后调用pthread_cond_signal(&taxi_cond)发现没有乘客，然后就直接结束线程了。。。。

正确的操作应该是：先到的Jack发现没有乘客，然后一直等待乘客，有乘客到了就直接走，而且我们应该统计一下乘客的数量

做如下改进：

1.增加乘客计数器，使得出租车在有乘客到达之后可以直接走，而不是又在原地等待别的乘客（僵死线程）

2.出租车到达函数加个while循环，没有乘客的时候一直等待，直到乘客到来

#include

#include

#include

#include

#include

#include

#include

using namespace std;

pthread_cond_t taxi_cond=PTHREAD_COND_INITIALIZER; //taix arrive cond

pthread_mutex_t taxi_mutex=PTHREAD_MUTEX_INITIALIZER;// sync mutex

void *traveler_arrive(void *name)

{

cout<<"Traveler:"<<(char*)name<<" needs a taxi now!"<

pthread_mutex_lock(&taxi_mutex);

pthread_cond_wait(&taxi_cond,&taxi_mutex);

pthread_mutex_unlock(&taxi_mutex);

cout<<"Traveler:"<<(char*)name<<" now got a taxi!"<

pthread_exit((void*)0);

}

void *taxi_arrive(void *name)

{

cout<<"Taxi:"<<(char*)name<<" arriver."<

pthread_exit((void*)0);

}

int main()

{

pthread_t tids[3];

int flag;

flag=pthread_create(&tids[0],NULL,taxi_arrive,(void*)("Jack"));

if(flag)

{

cout<<"pthread_create error:flag="<

return flag;

}

cout<<"time passing by"<

sleep(1);

flag=pthread_create(&tids[1],NULL,traveler_arrive,(void*)("Susan"));

if(flag)

{

cout<<"pthread_create error:flag="<

return flag;

}

cout<<"time passing by"<

sleep(1);

flag=pthread_create(&tids[2],NULL,taxi_arrive,(void*)("Mike"));

if(flag)

{

cout<<"pthread_create error:flag="<

return flag;

}

cout<<"time passing by"<

sleep(1);

void *ans;

for(int i=0; i<3; i++)

{

flag=pthread_join(tids[i],&ans);

if(flag)

{

cout<<"pthread_join error:flag="<

return flag;

}

cout<<"ans="<

}

return 0;

}

三.读写锁

可以多个线程同时读，但是不能多个线程同时写

1.读写锁比互斥锁更加具有适用性和并行性

2.读写锁最适用于对数据结构的读操作读操作次数多余写操作次数的场合！

3.锁处于读模式时可以线程共享，而锁处于写模式时只能独占，所以读写锁又叫做共享-独占锁

4.读写锁有两种策略：强读同步和强写同步

在强读同步中，总是给读者更高的优先权，只要写者没有进行写操作，读者就可以获得访问权限

在强写同步中，总是给写者更高的优先权，读者只能等到所有正在等待或者执行的写者完成后才能进行读

不同的系统采用不同的策略，比如航班订票系统使用强写同步，图书馆查阅系统采用强读同步

根据不同的业务场景，采用不同的策略

1）初始化的销毁读写锁

静态初始化：pthread_rwlock_t rwlock=
PTHREAD_RWLOCK_INITIALIZER

动态初始化：int pthread_rwlock_init(rwlock，NULL)，NULL代表读写锁采用默认属性

销毁读写锁：int pthread_rwlock_destory(rwlock)

在释放某个读写锁的资源之前，需要先通过pthread_rwlock_destory函数对读写锁进行清理。释放由pthread_rwlock_init函数分配的资源

如果你想要读写锁使用非默认属性，则attr不能为NULL，得给attr赋值

int pthread_rwlockattr_init(attr),给attr初始化

int
pthread_rwlockattr_destory(attr)，销毁attr

2）以写的方式获取锁，以读的方式获取锁，释放读写锁

int pthread_rwlock_rdlock(rwlock),以读的方式获取锁

int pthread_rwlock_wrlock(rwlock)，以写的方式获取锁

int pthread_rwlock_unlock(rwlock),释放锁

上面两个获取锁的方式都是阻塞的函数，也就是说获取不到锁的话，调用线程不是立即返回，而是阻塞执行，在需要进行写操作的时候，这种阻塞式获取锁的方式是非常不好的，你想一下，我需要进行写操作，不但没有获取到锁，我还一直在这里等待，大大拖累效率

所以我们应该采用非阻塞的方式获取锁：

int pthread_rwlock_tryrdlock(rwlock)

int pthread_rwlock_trywrlock(rwlock)

读写锁的样例：

#include

#include

#include

#include

#include

#include

#include

using namespace std;

int num=5;

pthread_rwlock_t rwlock;

void *reader(void *arg)

{

pthread_rwlock_rdlock(&rwlock);

cout<<"reader "<<(long)arg<<" got the lock"<

pthread_rwlock_unlock(&rwlock);

return 0;

}

void *writer(void *arg)

{

pthread_rwlock_wrlock(&rwlock);

cout<<"writer "<<(long)arg<<" got the lock"<

pthread_rwlock_unlock(&rwlock);

return 0;

}

int main()

{

int flag;

long n=1,m=1;

pthread_t wid,rid;

pthread_attr_t attr;

flag=pthread_rwlock_init(&rwlock,NULL);

if(flag)

{

cout<<"rwlock init error"<

return flag;

}

pthread_attr_init(&attr);

pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);//thread sepatate

for(int i=0;i

{

if(i%3)

{

pthread_create(&rid,&attr,reader,(void *)n);

cout<<"create reader "<

n++;

}else

{

pthread_create(&wid,&attr,writer,(void *)m);

cout<<"create writer "<

m++;

}

}

sleep(5);//wait other done

return 0;

}


分析：3个读线程，2个写线程，读线程比写线程多

当读写锁是写状态时，在锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞

当读写锁是读状态时，在锁被解锁之前，所有视图以读模式对它进行加锁的线程都可以得到访问权，但是以写模式对它进行加锁的线程会被阻塞

所以读写锁默认是强读模式！

四.信号量

信号量（sem）和互斥锁的区别：互斥锁只允许一个线程进入临界区，而信号量允许多个线程进入临界区

1）信号量初始化

int sem_init(&sem,pshared,v)

pshared为0表示这个信号量是当前进程的局部信号量

pshared为1表示这个信号量可以在多个进程之间共享

v为信号量的初始值

成功返回0，失败返回-1

2）信号量值的加减

int sem_wait(&sem):以原子操作的方式将信号量的值减去1

int sem_post(&sem):以原子操作的方式将信号量的值加上1

3）对信号量进行清理

int sem_destory(&sem)

通过信号量模拟2个窗口，10个客人进行服务的过程

样例：

#include

#include

#include

#include

#include

#include

#include

#include

using namespace std;

int num=10;

sem_t sem;

void *get_service(void *cid)

{

int id=*((int*)cid);

if(sem_wait(&sem)==0)

{

sleep(5);

cout<<"customer "<

cout<<"customer "<

sem_post(&sem);

}

return 0;

}

int main()

{

sem_init(&sem,0,2);

pthread_t customer[num];

int flag;

for(int i=0;i

{

int id=i;

flag=pthread_create(&customer[i],NULL,get_service,&id);

if(flag)

{

cout<<"pthread create error"<

return flag;

}else

{

cout<<"customer "<

}

sleep(1);

}

//wait all thread done

for(int j=0;j

{

pthread_join(customer[j],NULL);

}

sem_destroy(&sem);

return 0;

}


分析：信号量的值代表空闲的服务窗口，每个窗口一次只能服务一个人，有空闲窗口，开始服务前，信号量-1，服务完成后信号量+1

需要C/C++ Linux服务器开发学习资料私信“资料”（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享

相关推荐

winxp安装盘（winxp系统安装）

xp系统安装步骤如下1、将下载的xp系统iso压缩包文件下载到C盘之外的分区，比如下载到D盘，右键使用WinRAR等工具解压到当前文件夹或指定文件夹，不能解压到C盘和桌面，否则无法安装；?2、解压之后...

现在的win11稳定了吗（win11稳定嘛）

windows10更稳定，由于win11刚刚推出没多久，稳定差不够好，兼容性也有待提升，无论是应用还是游戏都会遇到不明程度的问题，因此，在日常的使用过程中，我们还是应当以稳定性为优先，选择win10是...

xp安装包下载到手机（xp系统安装包）

手机是基于ARM架构的处理器，而WindowsXP是基于x86架构的操作系统，因此无法直接在手机上安装WindowsXP。除非您的手机是使用Intel处理器，但这种情况非常罕见。如果您需要在手机上...

如何查看硬盘序列号（windows如何查看硬盘序列号）

1.打开开始菜单栏，输入【cmd】点击【确定】；2.在命令窗口依次输入【diskpart】-【listdisk】-【selectdisk0】；3.选好要查看的硬盘后，接着输入【detaildi...

虚拟机安装win7教程（虚拟机安装win7教程图解）

1.首先，下载并安装虚拟机软件，如VMwareWorkstation、VirtualBox等。2.打开虚拟机软件，创建一个新的虚拟机。3.在创建虚拟机的过程中，选择安装Windows7专业版的IS...

系统脱敏法的操作程序如何

系统脱敏疗法（systematicdesensitization）又称交互抑制法，是由美国学者沃尔普创立和发展的。这种方法主要是诱导求治者缓慢地暴露出导致神经症焦虑、恐惧的情境，并通过心理的放松状态...

闪迪u盘低级格式化工具（闪迪u盘格式化分配单元大小）

闪迪U盘格式化后速度变慢的可能原因及解决方法如下：文件系统问题：格式化时选择的文件系统类型可能会影响U盘的性能。常见的文件系统类型包括FAT32、NTFS和exFAT等。如果文件系统类型不合适，可能会...

psd文件下载（psd格式下载网站）

　　1、在photoshop中，不能通过置入的方法来加载PSD文件，因为，通过置入的方法加载PSD文件，它是以合并图层的方法把PSD文件加入，这样，就失去了PSD文件的所有图层信息。　　2、在文档中想...

宏碁官网下载win7系统（宏碁官方系统）

宏基笔记本win8系统换成win7步骤：1、更改bios设置，关闭“SecureBoot”功能，启用传统的“LegacyBoot”。2、制作u启动U盘启动盘，下载win7系统安装包3、设置U盘启动...

如何重装系统win7旗舰版32位

首先下载制作一个带系统的启动u盘，然后按以下步骤安装：1、首先关闭电脑上面的杀毒软件，2、进入bios选择u盘启动。3、插入启动u盘重新启动电脑4、进入pe系统镜像环节，选择要安装的系统（32位），然...

应用程序发生异常0xe0000008

先查看一下对应的软件是不是出现了损坏,也可以重装此软件。我们还可以尝试通过修改注册表来解决。按Win+R(或者在开始菜单搜索框输入“运行”)打开运行,然后输入“regedit”回车,打开注册表恢复原来...

笔记本连接wifi显示无法连接网络

笔记本电脑连接wifi时提示无法连接到这个网络1、打开电脑“控制面板”，点击“网络连接”，选择本地连接，右键点击本地连接图标后选“属性”，在“常规”选项卡中双击“Internet协议(TCP/IP)...

windowsc盘清理大师（c盘清理大师怎么样）

 C盘清理大师是一款流氓软件，可不是windows10里自带。在你的电脑上出现这个软件一般情况下可以证明你使用的系统是盗版的，系统采用的是网上流传的系统镜像制作的。在网上流传这些系统镜像文件...

realtek没声音如何设置（realtek怎么调出来）

你给无线连接配IP地址呗第一步：下载驱动精灵软件。第二步：安装驱动精灵软件。1、在打开的驱动软件安装窗口，确定程序安装路径后，点击：一键安装；2、正在安装。第三步：更新驱动程序。1、安装非常迅速，已经...

腾达路由器手机端登录入口（腾达路由器手机端登录入口在哪）

腾达路由器使用192.168.0.1或tendawifi.com作为登录地址。登录管理员页面的步骤：1、手机连接到腾达路由器的wifi信号；2、在手机上打开浏览器，在地址栏输入192.168.0.1后...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表
Copyright Your WebSite.Some Rights Reserved.