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

Python技术进阶 | 如何正确使用进程和线程?

off999 2024-10-19 07:20 24 浏览 0 评论

为了提高程序的运行效率，Python与其他语言一样，提供了多进程和多线程的开发方式，这篇文章我们来讲Python的多进程和多线程开发。

进程

Python提供了mutilprocessing模块，为多进程编程提供了友好的API，并且提供了多进程之间信息同步和通信的相关组件，如Queue、Event、Pool、Lock、Pipe、Semaphore、Condition等模块。

函数当做进程

Python中创建多进程的方式有2种：

  • 函数当做进程
  • 类当做进程

逻辑简单的任务一般使用函数当做进程，逻辑较多或代码结构复杂的建议使用类当做进程。

首先来看函数当做进程的例子：

# coding: utf8

import os
import time
import random
from multiprocessing import Process

def task(name):
    s = random.randint(1, 10)
    print 'pid: %s, name: %s, sleep %s ...' % (os.getpid(), name, s)
    time.sleep(s)

if __name__ == '__main__':
    # 创建5个子进程执行
    ps = []
    for i in range(5):
        p = Process(target=task, args=('p%s' % i, ))
        ps.append(p)
        p.start()
    
    # 主进程等待子进程结束
    for p in ps:
        p.join()
    
# Output:
# pid: 52361, name: p0, sleep 8 ...
# pid: 52362, name: p1, sleep 7 ...
# pid: 52363, name: p2, sleep 8 ...
# pid: 52364, name: p3, sleep 3 ...
# pid: 52365, name: p4, sleep 2 ...

使用p = Process(target=func, args=(arg1, arg2...))即可创建一个进程，调用p.start()启动一个进程，p.join()使得主进程等待子进程执行结束后才退出。

当这个程序执行时，你可以ps查看一下进程，会发现一共有6个进程在执行，其中包括1个主进程，5个子进程。

类当做进程

# coding: utf8

import os
import random
import time
from multiprocessing import Process

class P(Process):

    def run(self):
        s = random.randint(1, 10)
        print 'pid: %s, name: %s, sleep %s...' % (os.getpid(), self.name, s)
        time.sleep(s)

if __name__ == '__main__':
    # 创建5个进程并执行
    ps = []
    for i in range(5):
        p = P()
        ps.append(p)
        p.start()

    # 主进程等待子进程执行结束后退出
    for p in ps:
        p.join()
        
# Output:
# pid: 59138, name: P-2, sleep 5...
# pid: 59137, name: P-1, sleep 8...
# pid: 59139, name: P-3, sleep 8...
# pid: 59140, name: P-4, sleep 3...
# pid: 59141, name: P-5, sleep 6...

类P继承了Process，并重写了run方法，在调用start方法时会自动执行run方法，执行效果与上面类似。

Queue

如果多个进程之间需要通信，可以使用队列，Python提供了Queue模块，例子如下：

# coding: utf8

import time
import random
from multiprocessing import Process, Queue

class P1(Process):

    def __init__(self, queue):
        self.queue = queue
        super(P1, self).__init__()

    def run(self):
        # 此进程负责put数据
        print 'P1 put ...'
        for i in range(5):
            time.sleep(random.randint(1, 3))
            self.queue.put(i)
            print 'put: P1 -> %s' % i

class P2(Process):

    def __init__(self, queue):
        self.queue = queue
        super(P2, self).__init__()

    def run(self):
        # 此进程负责read数据
        print 'P2 read ...'
        while 1:
            i = self.queue.get()
            print 'get: P2 -> %s' % i

if __name__ == '__main__':
    # 创建多进程队列 使之可通信
    queue = Queue()

    # 创建进程
    p1 = P1(queue)
    p2 = P2(queue)

    # 启动进程
    p1.start()
    p2.start()

    # 主进程等待P1子进程执行
    p1.join()
    # P2执行的是死循环 只能强制结束
    p2.terminate()
    
# Output:
# P1 put ...
# P2 read ...
# put: P1 -> 0
# get: P2 -> 0
# put: P1 -> 1
# get: P2 -> 1
# put: P1 -> 2
# get: P2 -> 2
# put: P1 -> 3
# get: P2 -> 3
# put: P1 -> 4
# get: P2 -> 4

一共2个进程，一个进程使用queue.put()负责向队列写入数据，另一个进程使用queue.get()队列中读取数据，实现了2个进程之间的信息通信。

Pipe

上面提到队列的使用场景常用于一端写入数据，另一端读取数据进行操作。

如果进程两端在读取数据时同时也想写入数据要怎么做？

Python多进程模块中提供了Pipe，意为管道的意思，两端都可以进行读写操作。

# coding: utf8

import time
import random
from multiprocessing import Process, Pipe

class P1(Process):

    def __init__(self, pipe):
        self.pipe = pipe
        super(P1, self).__init__()

    def run(self):
        # send
        print 'P1 send ...'
        for i in range(3):
            time.sleep(random.randint(1, 2))
            self.pipe.send(i)
            print 'send: P1 -> %s' % i

        # recv
        print 'P1 recv ...'
        for i in range(3):
            i = self.pipe.recv()
            print 'recv: P1 -> %s' % i

class P2(Process):

    def __init__(self, pipe):
        self.pipe = pipe
        super(P2, self).__init__()

    def run(self):
        # recv
        print 'P2 recv ...'
        for i in range(3):
            i = self.pipe.recv()
            print 'recv: P2 -> %s' % i
            
        # send
        print 'P2 send ...'
        for i in range(3):
            time.sleep(random.randint(1, 2))
            self.pipe.send(i)
            print 'send: P2 -> %s' % i

if __name__ == '__main__':
    # 创建Pipe
    pipe1, pipe2 = Pipe()

    p1 = P1(pipe1)
    p2 = P2(pipe2)

    p1.start()
    p2.start()

    p1.join()
    p2.join()
    
# Output:
# P1 send ...
# P2 recv ...
# send: P1 -> 0
# recv: P2 -> 0
# send: P1 -> 1
# recv: P2 -> 1
# send: P1 -> 2
# P1 recv ...
# recv: P2 -> 2
# P2 send ...
# send: P2 -> 0
# recv: P1 -> 0
# send: P2 -> 1
# recv: P1 -> 1
# send: P2 -> 2
# recv: P1 -> 2

创建一个Pipe会返回2个管道，这2个管道分别交给2个进程，即可实现这2个进程之间的互相通信。

Event

如果需要在多进程之间控制某些事件的开始与停止，也就是在多进程进程保持同步信号信息，可使用Event：

# coding: utf8

import time
import random
from multiprocessing import Process, Queue, Event

class P1(Process):

    def __init__(self, queue, event):
        self.queue = queue
        self.event = event
        super(P1, self).__init__()

    def run(self):
        # 阻塞 等待主进程信号
        self.event.wait()
        print 'P1 put ...'
        for i in range(5):
            time.sleep(random.randint(1, 3))
            self.queue.put(i)
            print 'put: P1 -> %s' % i

class P2(Process):

    def __init__(self, queue, event):
        self.queue = queue
        self.event = event
        super(P2, self).__init__()

    def run(self):
        # 阻塞 等待主进程信号
        self.event.wait()
        print 'P2 read ...'
        while 1:
            i = self.queue.get()
            print 'get: P2 -> %s' % i
            
if __name__ == '__main__':
    # 队列
    queue = Queue()
    # 事件
    event = Event()

    p1 = P1(queue, event)
    p2 = P2(queue, event)

    p1.start()
    p2.start()

    # 主进程让子进程阻塞3秒
    print 'sleep 3s ...'
    time.sleep(3)
    # 向子进程发送信号 子进程向下执行
    event.set()

    p1.join()
    p2.terminate()
    
# Output:
# sleep 3s...
# P1 put ...
# P2 read ...
# put: P1 -> 0
# get: P2 -> 0
# put: P1 -> 1
# get: P2 -> 1
# put: P1 -> 2
# get: P2 -> 2
# put: P1 -> 3
# get: P2 -> 3
# put: P1 -> 4
# get: P2 -> 4

执行程序后，我们发现2个子进程在执行到event.wait()时，阻塞在此，直到主进程休眠3秒后执行event.set()时，子进程才得以向下执行。

使用Event可以控制进程之间的同步问题。

Pool

多进程虽然可以提高运行效率，但同时也不建议无限制的创建进程，过多的进程会给操作系统的调度和上下文切换带来更大的负担，进程越来越多也有可能导致效率下降。

在multiiprocessing模块中，提供了进程池模块Pool，理论来说同时执行的进程数与CPU核心相等，才会保证最高效的运行效率。

# coding: utf8

import os
import random
import time
from multiprocessing import Pool

def task(name):
    s = random.randint(1, 10)
    print 'pid: %s, name: %s, sleep %s ...' % (os.getpid(), name, s)
    time.sleep(s)

if __name__ == '__main__':
    # 大小为5的进程池 同一时刻最多只有5个进程执行
    pool = Pool(5)

    # 运行10个任务
    for i in range(10):
        pool.apply_async(task, ('p-%s' % i, ))

    # 必须先close才能join 表示不再添加新的进程
    pool.close()
    pool.join()

# Output:
# pid: 67193, name: p-0, sleep 3 ...
# pid: 67194, name: p-1, sleep 5 ...
# pid: 67195, name: p-2, sleep 5 ...
# pid: 67196, name: p-3, sleep 6 ...
# pid: 67197, name: p-4, sleep 9 ...
# pid: 67193, name: p-5, sleep 6 ...
# pid: 67194, name: p-6, sleep 5 ...
# pid: 67195, name: p-7, sleep 4 ...
# pid: 67196, name: p-8, sleep 3 ...
# pid: 67197, name: p-9, sleep 7 ...

上面代码定义了大小为5的进程池，也就是说不管向进程池里放入多少个任务，同一时刻只有5个进程在执行。

我们在编写多进程程序时，一般使用进程池的方式执行多个任务，保证高效的同时也避免资源的浪费

Lock

在执行多进程任务执行过程中，如果需要对同一资源（例如文件）进行访问时，为了防止一个进程操作的资源不被另一个进程篡改，可以使用Lock对其进行加锁互斥。

# coding: utf8

from multiprocessing import Process, Lock

class P1(Process):

    def __init__(self, lock, fp):
        self.lock = lock
        self.fp = fp
        super(P1, self).__init__()

    def run(self):
        # 只有一个进程能进入操作
        with self.lock:
            for i in range(5):
                f = open(self.fp, 'a+')
                f.write('p1 - %s\n' % i)
                f.close()

class P2(Process):

    def __init__(self, lock, fp):
        self.lock = lock
        self.fp = fp
        super(P2, self).__init__()

    def run(self):
        # 只有一个进程能进入操作
        with self.lock:
            for i in range(5):
                f = open(self.fp, 'a+')
                f.write('p2 - %s\n' % i)
                f.close()
                
if __name__ == '__main__':
    # 进程锁
    lock = Lock()
    fp = 'test.txt'
    p1 = P1(lock, fp)
    p2 = P2(lock, fp)

    p1.start()
    p2.start()

    p1.join()
    p2.join()

上面代码对同一个文件进行操作时，如果不加锁，2个进程会同时向文件写入内容。如果想保证写入顺序，在写文件之前使用Lock加锁，就能保证只有一个进程能进入操作文件。

Semaphore

如果有一种场景，需要多个进程同时执行一些任务或访问某个资源，但要限制最大参与的进程数量，那么就可以使用Semaphore信号量来控制。

# coding: utf8

import time
import os
from multiprocessing import Process, Semaphore

# 最大4个进程同时操作
semaphore = Semaphore(4)

def task(name):
    if semaphore.acquire():
        print 'pid: %s, name: %s, sleep 1 ...' % (os.getpid(), name)
        time.sleep(1)
        semaphore.release()

if __name__ == '__main__':
    ps = []
    for i in range(10):
        p = Process(target=task, args=('p%s' % i, ))
        ps.append(p)
        p.start()
    for p in ps:
        p.join()

# Output:
# pid: 37147, name: p0, sleep 1 ...
# pid: 37148, name: p1, sleep 1 ...
# pid: 37149, name: p2, sleep 1 ...
# pid: 37150, name: p3, sleep 1 ...

# pid: 37151, name: p4, sleep 1 ...
# pid: 37152, name: p5, sleep 1 ...
# pid: 37153, name: p6, sleep 1 ...
# pid: 37154, name: p7, sleep 1 ...

# pid: 37155, name: p8, sleep 1 ...
# pid: 37156, name: p9, sleep 1 ...

执行上面的代码，你会发现虽然创建了10个进程，但同一时刻只有4个进程能能够执行真正的逻辑。

Condition

如果你有使用Lock + Event结合的场景，可以使用Condition，它基本上包含了这2种特性，在加锁的同时，还可以根据逻辑条件让其他进程等待或重新唤醒。

# coding: utf8

import time
import random
from multiprocessing import Process, Queue, Condition

def produer(queue, condition):
    while 1:
        # 获取锁
        if condition.acquire():
            if not queue.empty():
                # 等待其他进程唤醒
                condition.wait()
            i = random.randint(1, 10)
            queue.put(i)
            print 'produer --> %s' % i
            # 唤醒其他进程
            condition.notify()
            # 释放锁
            condition.release()
            time.sleep(1)

def consumer(queue, condition):
    while 1:
        # 获取锁
        if condition.acquire():
            if queue.empty():
                # 等待其他进程唤醒
                condition.wait()
            i = queue.get()
            print 'consumer --> %s' % i
            # 唤醒其他进程
            condition.notify()
            # 释放锁
            condition.release()
            time.sleep(1)
            
if __name__ == '__main__':
    queue = Queue()
    condition = Condition()
    p1 = Process(target=produer, args=(queue, condition))
    p2 = Process(target=consumer, args=(queue, condition))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    
# Output:
# produer --> 10
# consumer --> 10
# produer --> 4
# consumer --> 4
# produer --> 5
# consumer --> 5
# ...

Condition是一种更高级的控制进程同步和资源控制的方式。

线程

线程是进程执行的最小单位，比进程更轻量，一个进程至少包含一个线程，一个进程中的所有线程共享这个进程的地址空间和资源句柄。

在Python代码执行中，默认是单进程单线程执行的。

如果想要编写多线程程序，Python也提供了threading模块，同时也提供了线程之间信息同步和信号控制的组件。

函数当做线程

创建线程与创建进程类似，也有2种方式：

  • 函数当做线程
  • 类当做线程

函数当做线程的例子如下：

# coding: utf8

import threading

def run(name):
    for i in range(3):
        print '%s --> %s' % (name, i)

if __name__ == '__main__':
    # 创建2个线程
    t1 = threading.Thread(target=run, args=('t1', ))
    t2 = threading.Thread(target=run, args=('t2', ))
    # 开始执行
    t1.start()
    t2.start()
    # 主线程等待其他线程结束
    t1.join()
    t2.join()
    
# Output:
# t1 --> 0
# t2 --> 0
# t2 --> 1
# t2 --> 2
# t1 --> 1
# t1 --> 2

与进程很类似，t = threading.Thread(target=func, args=(arg1, arg2...))创建一个线程，t.start()开始执行线程，t.join()使主线程等待其他线程执行结束。

类当做线程

# coding: utf8

import threading

class A(threading.Thread):

    def run(self):
        for i in range(5):
            print self.name, i

if __name__ == '__main__':
    a1 = A()
    a2 = A()
    # 执行线程
    a1.start()
    a2.start()
    # 主线程等待其他线程结束
    a1.join()
    a2.join()

只要继承threading.Thread类，重写run方法，这个类就会以多线程的方式执行run方法里的逻辑。

Queue

多线程之间也可以使用队列进行数据传输：

# coding: utf8

import time
import random
from Queue import Queue
from threading import Thread

class T1(Thread):

    def __init__(self, queue):
        self.queue = queue
        super(T1, self).__init__()

    def run(self):
        print 'T1 put ...'
        for i in range(5):
            time.sleep(random.randint(1, 3))
            self.queue.put(i)
            print 'put: T1 -> %s' % i

class T2(Thread):

    def __init__(self, queue):
        self.queue = queue
        self._running = True
        super(T2, self).__init__()

    def stop(self):
        self._running = False

    def run(self):
        print 'T2 read ...'
        while self._running:
            i = self.queue.get()
            print 'get: T2 -> %s' % i
            
if __name__ == '__main__':
    # 创建多线程队列
    queue = Queue()

    # 创建进程
    t1 = T1(queue)
    t2 = T2(queue)

    # 启动进程
    t1.start()
    t2.start()

    # T2线程10秒后停止
    time.sleep(10)
    t2.stop()

    # 主进程等待线程执行
    t1.join()
    t2.join()
    
# Output:
# T1 put ...
# T2 read ...
# put: T1 -> 0
# get: T2 -> 0
# put: T1 -> 1
# get: T2 -> 1
# put: T1 -> 2
# get: T2 -> 2
# put: T1 -> 3
# get: T2 -> 3
# put: T1 -> 4
# get: T2 -> 4

Event

多线程的同步也有Event可以控制：

# coding: utf8

import time
import random
from Queue import Queue
from threading import Thread, Event

class T1(Thread):

    def __init__(self, queue, event):
        self.queue = queue
        self.event = event
        super(T1, self).__init__()

    def run(self):
        # 阻塞 等待主线程信号
        self.event.wait()
        print 'T1 put ...'
        for i in range(5):
            time.sleep(random.randint(1, 3))
            self.queue.put(i)
            print 'put: T1 -> %s' % i


class T2(Thread):

    def __init__(self, queue, event):
        self.queue = queue
        self.event = event
        self._running = True
        super(T2, self).__init__()

    def stop(self):
        self._running = False

    def run(self):
        # 阻塞 等待主线程信号
        self.event.wait()
        print 'T2 read ...'
        while self._running:
            i = self.queue.get()
            print 'get: T2 -> %s' % i

if __name__ == '__main__':
    # 队列
    queue = Queue()
    # 多线程事件
    event = Event()

    t1 = T1(queue, event)
    t2 = T2(queue, event)

    t1.start()
    t2.start()

    # 主线程让其他线程阻塞3秒
    print 'sleep 3s...'
    time.sleep(3)
    event.set()

    # T2线程10秒后停止
    time.sleep(10)
    t2.stop()

    t1.join()
    t2.join()
    
# Output:
# sleep 3s...
# T1 put ...
# T2 read ...
# put: T1 -> 0
# get: T2 -> 0
# put: T1 -> 1
# get: T2 -> 1
# put: T1 -> 2
# get: T2 -> 2
# put: T1 -> 3
# get: T2 -> 3
# put: T1 -> 4

Pool

避免无限制的创建线程，使用线程池执行任务：

# coding: utf8

import time
import random
from multiprocessing.pool import ThreadPool

def task(name):
    s = random.randint(1, 10)
    print 'name: %s, sleep %s ...' % (name, s)
    time.sleep(s)

if __name__ == '__main__':
    # 大小为5的线程池
    pool = ThreadPool(5)

    # 运行10个任务
    for i in range(10):
        pool.apply_async(task, ('t-%s' % i, ))

    # 必须先close才能join 表示不再添加新的线程
    pool.close()
    pool.join()
    
# Output:
# name: t-0, sleep 1 ...
# name: t-1, sleep 4 ...
# name: t-2, sleep 4 ...
# name: t-3, sleep 10 ...
# name: t-4, sleep 9 ...

# name: t-5, sleep 8 ...
# name: t-6, sleep 2 ...
# name: t-7, sleep 2 ...
# name: t-8, sleep 4 ...
# name: t-9, sleep 6 ...

Semaphore

允许多个线程同时操作某个资源并限制最大线程数，使用Semaphore：

# coding: utf8

import time
import os
from threading import Thread, Semaphore

# 最大4个线程同时操作
semaphore = Semaphore(4)

def task(name):
    if semaphore.acquire():
        print 'name: %s, sleep 1 ...' % name
        time.sleep(1)
        semaphore.release()

if __name__ == '__main__':
    ts = []
    for i in range(10):
        t = Thread(target=task, args=('t%s' % i, ))
        ts.append(t)
        t.start()
    for t in ts:
        t.join()

# Output:
# name: t0, sleep 1 ...
# name: t2, sleep 1 ...
# name: t1, sleep 1 ...
# name: t3, sleep 1 ...

# name: t4, sleep 1 ...
# name: t5, sleep 1 ...
# name: t7, sleep 1 ...
# name: t6, sleep 1 ...

# name: t8, sleep 1 ...
# name: t9, sleep 1 ...

Condition

与多进程类似，Condition是Lock + Event的结合：

# coding: utf8

import time
import random
from Queue import Queue
from threading import Thread, Condition

def produer(queue, condition):
    for i in range(5):
        # 获取锁
        if condition.acquire():
            if not queue.empty():
                # 等待其他线程唤醒
                condition.wait()
            i = random.randint(1, 10)
            queue.put(i)
            print 'produer --> %s' % i
            # 唤醒其他线程
            condition.notify()
            # 释放锁
            condition.release()
            time.sleep(1)

def consumer(queue, condition):
    for i in range(5):
        # 获取锁
        if condition.acquire():
            if queue.empty():
                # 等待其他线程唤醒
                condition.wait()
            i = queue.get()
            print 'consumer --> %s' % i
            # 唤醒其他线程
            condition.notify()
            # 释放锁
            condition.release()
            time.sleep(1)
            
if __name__ == '__main__':
    queue = Queue()
    condition = Condition()
    t1 = Thread(target=produer, args=(queue, condition))
    t2 = Thread(target=consumer, args=(queue, condition))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    
# Output:
# produer --> 3
# consumer --> 3
# produer --> 2
# consumer --> 2
# produer --> 2
# consumer --> 2
# produer --> 7
# consumer --> 7
# produer --> 5
# consumer --> 5

concurrent模块

上面介绍了很多进程、线程各种常用的开发方式，其实最常用的编程模式还是使用进程池或线程池来执行进程、线程。

这里有必要推荐一下concurrent模块，这个模块非常友好的封装了进程和线程最常用的操作，使用起来更简单易用。

并且在Python3.2以后，已经是纳入官方标准模块。

Python3.2以下需要手动安装此模块：

pip install futures

多进程

# coding: utf8

from concurrent.futures import ProcessPoolExecutor

def task(total):
    """模拟CPU密集运算"""
    num = 0
    for i in range(total):
        num += i
    return num

if __name__ == '__main__':
    # 进程池
    pool = ProcessPoolExecutor(max_workers=5)
    # 批量任务 放入进程池执行
    result = pool.map(task, [100, 1000, 10000, 100000])
    # 输出结果
    for item in result:
        print item

使用ProcessPoolExecutor创建进程池，调用pool.map方法批量加入任务并执行，然后输出每个进程的执行结果。

也可以使用submit提交单个任务在进程池中执行：

# coding: utf8

from concurrent.futures import ProcessPoolExecutor

def task(total):
    """模拟CPU密集任务"""
    num = 0
    for i in range(total):
        num += i
    return num

if __name__ == '__main__':
    # 进程池
    pool = ProcessPoolExecutor(max_workers=5)

    # 使用submit提交任务
    results = []
    results.append(pool.submit(task, 100))
    results.append(pool.submit(task, 1000))
    results.append(pool.submit(task, 10000))
    results.append(pool.submit(task, 10000))

    # 输出结果
    for future in results:
        print future.result()

注意，pool.submit提交后返回的是Future对象，它意味着在未来的某个时刻才会得到结果，所以在输出结果时，需要调用future.result()方法拿到真正的执行结果。

多线程

线程池的方式与进程池类似，只需把ProcessPoolExecutor换成ThreadPoolExecutor即可：

# coding: utf8

import requests
from concurrent.futures import ThreadPoolExecutor

def task(url):
    """模拟IO密集任务"""
    return requests.get(url).status_code

if __name__ == '__main__':
    # 线程池
    pool = ThreadPoolExecutor(max_workers=5)

    # 批量任务 放入线程池执行
    urls = ['http://www.baidu.com', 'http://www.163.com', 'http://www.taobao.com']
    result = pool.map(task, urls)

    # 输出结果
    for item in result:
        print item
# coding: utf8

import requests
from concurrent.futures import ThreadPoolExecutor

def task(url):
    """模拟IO密集运算"""
    return requests.get(url).status_code

if __name__ == '__main__':
    # 线程池
    pool = ThreadPoolExecutor(max_workers=5)

    # 使用submit 提交任务到线程池
    results = []
    results.append(pool.submit(task, 'http://www.baidu.com'))
    results.append(pool.submit(task, 'http://www.163.com'))
    results.append(pool.submit(task, 'http://www.taobao.com'))

    # 输出结果
    for future in results:
        print future.result()

相关推荐

windows7安装windows10（windows7安装光盘下载）

在安装Win7时，出现提示“Windows无法安装到这个磁盘。这台计算机的硬件可能不支持启动到此磁盘。请确保在计算机的bios菜单中启用了磁盘的控制器。”　解决方法：　1.如果之前你做过BIOS设置，...

装机配置模拟器（装机配置模拟器教程）
装机配置模拟器（装机配置模拟器教程）

装机模拟器2好装机模拟器2装系统方法1.在游戏PC装机模拟器里,有时候我们修理好电脑之后,发现电脑没有安装操作系统,这时候应该先安装系统。2.第一步,点击PC装机模拟器游戏,登录游戏。3.第二步,进入游戏之后,找到需要没有安装操作系统的电脑...

2025-11-10 21:51 off999

电脑网络正常但是上不了网（网络正常但电脑无法上网）

分析如下1、首先检查网卡的问题，打开电脑后，打开电脑右下角的WiFi连接，然后从里面的网络和共享中心检查，打开网络和共享中心后，出现对话框，在对话框左侧上方找到更改适配器设置，单击左键打开，就可以发现...

vs2008安装包下载（vs2008下载官方下载）

vs2008是面向WindowsVista、Office2007、Web2.0的下一代开发工具，VS2008引入了250多个新特性，整合了对象、关系型数据、XML的访问方式,语言更加简洁。使用V...

怎么换系统win7（怎么换系统盘固态硬盘）
  • 怎么换系统win7（怎么换系统盘固态硬盘）
  • 怎么换系统win7（怎么换系统盘固态硬盘）
  • 怎么换系统win7（怎么换系统盘固态硬盘）
  • 怎么换系统win7（怎么换系统盘固态硬盘）
cad2018序列号（cad2018序列码）

AutoCAD2018序列号和密钥：序列号：356-72378422，666-69696969,667-98989898,400-45454545,066-66666666等密钥：001J1CA...

恢复出厂设置win7（恢复出厂设置win11）
  • 恢复出厂设置win7（恢复出厂设置win11）
  • 恢复出厂设置win7（恢复出厂设置win11）
  • 恢复出厂设置win7（恢复出厂设置win11）
  • 恢复出厂设置win7（恢复出厂设置win11）
ip检测网站（ip地址测试）

IP检测工具(IPNetChecker)V1.5.2是一个简易实用，功能强大的网络监控软件，使您可以检查互联网和局域网上的IP主机的网络状态。IP检测工具(IPNetChecker)V1.5....

云电脑app哪个好（手机云电脑app哪个最好）

答：以下是一些比较好的云电脑应用程序推荐：1.AnyDesk-支持Windows、MacOS、Linux、Android和iOS，可用于远程访问和控制PC或移动设备。2.Splashtop...

怎样注册邮箱163免费（怎样注册邮箱163免费账号）

一、工具：电脑（联网）、浏览器二、操作步骤：【1】打开浏览器，找到“163邮箱”，点击。【2】点击右边的“注册”。【3】网站默认注册手机号码邮箱，填写信息，点击“注册”。若不想泄漏手机号码或不想使用手...

微软surface pro 6（微软surface pro 6可以扩容吗）

SurfacePro6的接口包含：1个标准尺寸USB3.0端口，3.5mm耳机插孔，MiniDisplayPort，1个SurfaceConnect端口，Surface专业键盘盖端口，microSDX...

电源已接通未充电怎么回事（电源已接通未充电 真正解决办法）

原因分析:出现这样的原因有可能是长时间没有充电,导致电池的内部电量耗完后亏电严重,只是电脑充电的保护,不让过充而已,只要设置一下电池选项一般就可以解决问题了。解决方法:1、关机,拔下电源,拔出电池,...

华为云会议app下载（华为云会议下载）

 华为云会议可以在PC客户端或者手机客户端上一键发起立即会议,1秒创会。然后在会中选择企业通讯录中的人加入,系统会自动呼叫这些与会人,接听后即加入会议。ZOOM是一个云会议服务平台，为客户提...

路由器重置方法（路由器重置方法详细步骤）

路由器靠近WAN口边上的有一个小孔用于路由器的重置，路由器配置完成后，我们可能会忘记他的用户名或者是密码，那么我们可以把它恢复到出厂设置，再靠近万口或电源之间，有一个小孔，用一个尖锐的金属查一下大约五...

100个有效qq号以及密码（有效qq号和密码大全）

如果你的电脑知识好的话，不妨用一些复合密码！SHIFT+一些特殊符号，字母，数字！虽然麻烦了点，但总比被人盗号了的好，是吧！最好还用手机绑定一下，这样的话方便改密码也不怕QQ被盗了哦。。。QQ密码找回...

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

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