进程(并发,并行) join start 进程池 (同步异步)

一、背景知识

  顾名思义,进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。进程的概念起源于操作系统,是操作系统最核心的概念,也是操作系统提供的最古老也是最重要的抽象概念之一。操作系统的其他所有内容都是围绕进程的概念展开的。

  PS:即使可以利用的cpu只有一个(早期的计算机确实如此),也能保证支持(伪)并发的能力。将一个单独的cpu变成多个虚拟的cpu(多道技术:时间多路复用和空间多路复用+硬件上支持隔离),没有进程的抽象,现代计算机将不复存在。

必备理论

#一 操作系统的作用:1:隐藏丑陋复杂的硬件接口,提供良好的抽象接口2:管理、调度进程,并且将多个进程对硬件的竞争变得有序#二 多道技术: 1.产生背景:针对单核,实现并发ps:现在的主机一般是多核,那么每个核都会利用多道技术有4个cpu,运行于cpu1的某个程序遇到io阻塞,会等到io结束再重新调度,会被调度到4个cpu中的任意一个,具体由操作系统调度算法决定。核心2.空间上的复用:如内存中同时有多道程序3.时间上的复用:复用一个cpu的时间片强调:遇到io切,占用cpu时间过长也切,核心在于切之前将进程的状态保存下来,这样才能保证下次切换回来时,能基于上次切走的位置继续运行

二、多进程概念

1、进程:正在进行的一个过程或者说一个任务。而负责执行任务则是cpu。进程有如下三个状态:

 

  其实在两种情况下会导致一个进程在逻辑上不能运行,

  1. 进程挂起是自身原因,遇到I/O阻塞,便要让出CPU让其他进程去执行,这样保证CPU一直在工作

  2. 与进程无关,是操作系统层面,可能会因为一个进程占用时间过多,或者优先级等原因,而调用其他的进程去使用CPU。

2、进程与程序的区别:程序仅仅只是一堆代码而已,而进程指的是程序的运行过程。

    强调:同一个程序执行两次,那也是两个进程,比如打开网易云音乐,虽然都是同一个软件,但是一个可以播放音乐,一个可以播放mv。

举例(单核+多道,实现多个进程的并发执行):egon在一个时间段内有很多任务要做:python备课的任务,写书的任务,交女朋友的任务,王者荣耀上分的任务,  但egon同一时刻只能做一个任务(cpu同一时间只能干一个活),如何才能玩出多个任务并发执行的效果?egon备一会课,再去跟李杰的女朋友聊聊天,再去打一会王者荣耀....这就保证了每个任务都在进行中

3、并发与并行:

无论是并行还是并发,在用户看来都是'同时'运行的,不管是进程还是线程,都只是一个任务而已,真是干活的是cpu,cpu来做这些任务,而一个cpu同一时刻只能执行一个任务

  并发:针对只有一个cpu执行多个进程的情况。是伪并行,即看起来是同时运行。单个cpu+多道技术就可以实现并发。

  并行:针对多个cpu执行多个进程的情况,并行也属于并发。

  单核下,可以利用多道技术,多个核,每个核也都可以利用多道技术(多道技术是针对单核而言的

         有四个核,六个任务,这样同一时间有四个任务被执行,假设分别被分配给了cpu1,cpu2,cpu3,cpu4,

         一旦任务1遇到I/O就被迫中断执行,此时任务5就拿到cpu1的时间片去执行,这就是单核下的多道技术

         而一旦任务1的I/O结束了,操作系统会重新调用它(需知进程的调度、分配给哪个cpu运行,由操作系统说了算),可能被分配给四个cpu中的任意一个去执行

 

 三、同步\异步and阻塞\非阻塞

同步是指:发送方发出数据后,等接收方发回响应以后才发下一个数据包的通讯方式。

异步是指:发送方发出数据后,不等接收方发回响应,接着发送下个数据包的通讯方式。

同步:

#所谓同步,就是在发出一个功能调用时,在没有得到结果之前,该调用就不会返回。
  按照这个定义,其实绝大多数函数都是同步调用。但是一般而言,我们在说同步、异步的时候,特指那些需要其他部件协作或者需要一定时间完成的任务。
#举例: #1. multiprocessing.Pool下的apply #发起同步调用后,就在原地等着任务结束,根本不考虑任务是在计算还是在io阻塞,总之就是一股脑地等任务结束 #2. concurrent.futures.ProcessPoolExecutor().submit(func,).result() #3. concurrent.futures.ThreadPoolExecutor().submit(func,).result()

异步:

#异步的概念和同步相对。当一个异步功能调用发出后,调用者不能立刻得到结果。当该异步功能完成后,通过状态、通知或回调来通知调用者。  
  如果异步功能用状态来通知,那么调用者就需要每隔一定时间检查一次,效率就很低(有些初学多线程编程的人,总喜欢用一个循环去检查某个变量的值,这其实是一 种很严重的错误)。
  如果是使用通知的方式,效率则很高,因为异步功能几乎不需要做额外的操作。至于回调函数,其实和通知没太多区别。
#举例: #1. multiprocessing.Pool().apply_async() #发起异步调用后,并不会等待任务结束才返回,相反,会立即获取一个临时结果(并不是最终的结果,可能是封装好的一个对象)。 #2. concurrent.futures.ProcessPoolExecutor(3).submit(func,) #3. concurrent.futures.ThreadPoolExecutor(3).submit(func,)

阻塞:

#阻塞调用是指调用结果返回之前,当前线程会被挂起(如遇到io操作)。函数只有在得到结果之后才会将阻塞的线程激活。有人也许会把阻塞调用和同步调用等同起来,实际上他是不同的。
对于同步调用来说,很多时候当前线程还是激活的,只是从逻辑上当前函数没有返回而已。
#举例: #1. 同步调用:apply一个累计1亿次的任务,该调用会一直等待,直到任务返回结果为止,但并未阻塞住(即便是被抢走cpu的执行权限,那也是处于就绪态); #2. 阻塞调用:当socket工作在阻塞模式的时候,如果没有数据的情况下调用recv函数,则当前线程就会被挂起,直到有数据为止。

非阻塞:

#非阻塞和阻塞的概念相对应,指在不能立刻得到结果之前也会立刻返回,同时该函数不会阻塞当前线程。

小结:

#1. 同步与异步针对的是函数/任务的调用方式:同步就是当一个进程发起一个函数(任务)调用的时候,一直等到函数(任务)完成,而进程继续处于激活状态。而异步情况下是当一个进程发起一个函数(任务)调用的时候,不会等函数返回,而是继续往下执行当,函数返回的时候通过状态、通知、事件等方式通知进程任务完成。#2. 阻塞与非阻塞针对的是进程或线程:阻塞是当请求不能满足的时候就将进程挂起,而非阻塞则不会阻塞当前进程

 

 

 四、多进程实现

1、multiprocessing模块介绍

  Python提供了multiprocessing。multiprocessing模块用来开启子进程,并在子进程中执行我们定制的任务(比如函数),该模块与多线程模块threading的编程接口类似。 multiprocessing模块的功能众多:支持子进程、通信和共享数据、执行不同形式的同步,提供了Process、Queue、Pipe、Lock等组件。  需要再次强调的一点是:与线程不同,进程没有任何共享状态,进程修改的数据,改动仅限于该进程内。

2、Process类介绍:为创建进程的类

主要方法:

#p为子进程

p.start():启动进程,并调用该子进程中的p.run() 
p.run():进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法  
p.terminate():强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放,进而导致死锁
p.is_alive():如果p仍然运行,返回True
p.join([timeout]):主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)。timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程

主要属性:

#p为子进程
p.daemon默认值为False,如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止,并且设定为True后,p不能创建自己的新进程,必须在p.start()之前设置
p.name:进程的名称
p.pid:进程的pid
p.exitcode:进程在运行时为None、如果为–N,表示被信号N结束(了解即可)
p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性,这类连接只有在具有相同的身份验证键时才能成功(了解即可)

3、创建并开启子进程

  方式一:(常用)

from multiprocessing import Process
import timedef task(name):print('%s is running' %name)time.sleep(2)if __name__ == '__main__': #在windows系统下,开子进程的代码必须写到这一行下面p=Process(target=task,args=('egon',))p.start() #只是在给操作系统发了一个信号,让操作系统去开进程(申请内存+拷贝父进程的地址空间)print('')

 

from multiprocessing import Process
import time
def work(name):print('%s is piaoing' %name)time.sleep(5)print('%s piao end' %name)
if __name__=='__main__':                 #windows系统必须加p=Process(target=work,args=('egon',))#args传参必须是个元组括号内要加逗号,
只是在给操作系统发一个信号,让操作系统去开进程
# # (申请内存,拷贝父进程的地址空间) p干的活是work 也可以以字典形式传:kwargs={'name':'egon'} p.start()print('主进程')

方式二:run()  名字是固定的

# multi 多 process进程
from multiprocessing import Process
import timeclass Myprocess(Process):  # 自己的类def __init__(self,name):super().__init__()  # 保证有父类的功能self.name=namedef run(self):print('%s is running' % self.name)time.sleep(2)if __name__ == '__main__':p = Myprocess('egon')p.start()  # 调的是p.run()print('')

 

from multiprocessing import Process
import time
class work(Process):def __init__(self,name):super(work, self).__init__()  # super()括号内的参数可以不用传,,保证有父类的功能self.name=namedef run(self):                            #方法名run()不可以更换print('%s is piaoing' %self.name)time.sleep(5)print('%s piao end' %self.name)
if __name__=='__main__':                      #windows系统必须加p=work('egon')p.start()   # 调的是p.run()print('主进程')

 

为什么python运行的程序在系统是python.exe
python3 test.py ----> python.exe

 

当前进程ID : print(os.getpid())

 

解释器pycharm(运行python)的进程id : print(os.getppid())

 

| 为管道符,在cmd输tasklist  是全部运行的进程,tasklist |findstr python 过滤出python

 

注意:进程的直接内存空间是彼此隔离的,如下例:

 

from multiprocessing import Process
n=100                 
#在windows系统中应该把全局变量定义在if __name__ == '__main__'之上 def work():global nn=0print('子进程内: ',n) if __name__ == '__main__':p=Process(target=work)p.start() #结果总为:0print('主进程内: ',n) #结果总为:100

 

4、socket并发编程实例

  可以实现多个客户端与服务端进行交流。

服务端:

from socket import *
from multiprocessing import Processserver=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server.bind(('127.0.0.1',8080))
server.listen(5)def talk(conn):while True:try:msg=conn.recv(1024)if not msg:breakconn.send(msg.upper())except Exception:breakif __name__ == '__main__':while True:conn,client_addr=server.accept()p=Process(target=talk,args=(conn,))p.start()

客户端:

#多个客户端
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))
while True:msg=input('>>: ').strip()if not msg:continueclient.send(msg.encode('utf-8'))msg=client.recv(1024)print(msg.decode('utf-8'))

 

 

将进程干死:terminate

 

5、jion()方法详解

  join方法的主要作用是等待子进程结束后执行主进程。

基于谁开的子进程谁来关

标准版
from multiprocessing import Process
import time,random
def func(name):print('%s is running'% name)time.sleep(random.randint(1,3))print('%s is runend'% name)if __name__ == '__main__':p1 = Process(target=func ,args=('egon',))p2 = Process(target=func ,args=('alex',))p3 = Process(target=func ,args=('lishi',))p4 = Process(target=func ,args=('jassin',))p1.start()p2.start()p3.start()p4.start()print('zhu')# 精简版
from multiprocessing import Process
import time,randomdef piao(name):print('%s is piaoing' %name)time.sleep(random.randint(1,3))print('%s is done' %name)if __name__ == '__main__':p1 = Process(target=piao, args=('alex',))p2 = Process(target=piao, args=('wxx',))p3 = Process(target=piao, args=('yxx',))p_l = [p1, p2, p3]for p in p_l:p.start()for p in p_l:p.join()print('')

 

并行效果:

 

from multiprocessing import Process
import time
def piao(name):print('%s is piaoing' %name)time.sleep(3)print('%s is piao end' %name)
if __name__=='__main__':p1=Process(target=piao,args=('egon',))p2=Process(target=piao,args=('alex',))p3=Process(target=piao,args=('yuanhao',))p4=Process(target=piao,args=('wupeiqi',))start_time=time.time()p1.start()p2.start()p3.start()p4.start()p1.join()p2.join()p3.join()p4.join()end_time=time.time()print(end_time-start_time)                   #结果为:3.多print('主线程')                               #最后才被打印
egon is running
lishi is running
alex is running
jassin is running
egon is run end
lishi is run end
alex is run end
jassin is run end
3.2911880016326904
zhu

  解释:p.join()是让主线程等待p的结束,卡住的是主线程而绝非进程p,进程只要start就会在开始运行了,所以p1-p4.start()时,系统中已经有四个并发的进程了而我们p1.join()是在等p1结束,没错p1只要不结束主线程就会一直卡在原地,这也是问题的关键join是让主线程等,而p1-p4仍然是并发执行的,p1.join的时候,其余p2,p3,p4仍然在运行,等p1.join结束,可能p2,p3,p4早已经结束了,这样p2.join,p3.join.p4.join直接通过检测,无需等待所以4个join花费的总时间仍然是耗费时间最长的那个进程运行的时间。

串行效果:

from multiprocessing import Process
import time
def run(name):print('%s is running' %name)time.sleep(3)print('%s is run end'%name)
if __name__ == '__main__':p1 = Process(target=run,args=('egon',))p2 = Process(target=run,args=('alex',))p3 = Process(target=run,args=('lishi',))p4 = Process(target=run,args=('jassin',))start_time = time.time()p1.start()p1.join()p2.start()p2.join()p3.start()p3.join()p4.start()p4.join()end_time = time.time()print(end_time - start_time)print('zhu')

 

结果:
egon is running
egon is run end
alex is running
alex is run end
lishi is running
lishi is run end
jassin is running
jassin is run end
12.697726249694824
zhu

 

 

解释:以上p1,p2,p3,p4进程是上一个子进程执行完才逐一被启动,形成串行效果。

 

六、进程池(Pool)

  多进程是实现并发的主要手段之一,但是通常会有如下问题:a.很明显需要并发执行的任务通常要远大于核数;b.一个操作系统不可能无限开启进程,通常有几个核就开几个进程;c.进程开启过多,效率反而会下降(开启进程是需要占用系统资源的,而且开启多余核数目的进程也无法做到并行)。

  Pool可以提供指定数量的进程,供用户调用,当有新的请求提交到pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到规定最大值,那么该请求就会等待,直到池中有进程结束,就重用进程池中的进程。执行任务的进程数始终位进程池中指定的那几个。

1、同步调用

  同步调用:提交完任务后,在原地等待任务结束,一旦结束可以立刻拿到结果。

from concurrent.futures import ProcessPoolExecutor
import time,random,os
def run(name,n):print('%s is running %s' %(name,os.getpid()))time.sleep(1)return n**2
if __name__ == '__main__':p=ProcessPoolExecutor(4)for i in range(10):res=p.submit(run,'alex %s' %i,i).result() #同步调用#等进程执行完,并能得到结果,然后才开启下一个进程,相当于串行 print(res)p.shutdown(wait=True)print('',os.getpid())

 

2、异步调用

  异步调用:提交完任务后,不会在原地等待任务结束,会继续提交下一次任务,等到所有任务都结束后,才能get结果。

from concurrent.futures import ProcessPoolExecutor
import time,os
import random
def work(n):print('%s is working' %(os.getpid()))time.sleep(1)return n**2if __name__=='__main__':p=ProcessPoolExecutor(4)                              #从无到有开启4个进程,而且一直是这4个进程objs=[]for i in range(10):objs=p.submin(work,'alex %s'%i,i)  #提交任务,不会在原地等结果
        objs.append(obj)
'''异步apply_async用法:如果使用异步提交的任务,主进程需要使用jion,等待进程池内任务都处理完,然后可以用get收集结果,否则,主进程结束,进程池可能还没来得及执行,也就跟着一起结束了'''p.shutdown(wait = True)print('主',os.geipid())for obj in objs:print(obj.result())
''

 

'''
提交/调用任务的方式有两种:同步调用:提交/调用一个任务,然后就在原地等着,等到该任务执行完毕拿到结果,再执行下一行代码异步调用: 提交/调用一个任务,不在原地等着,直接执行下一行代码,结果?'''# from multiprocessing import Process,Pool
from concurrent.futures import ProcessPoolExecutor
import time,random,osdef piao(name,n):print('%s is piaoing %s' %(name,os.getpid()))time.sleep(1)return n**2if __name__ == '__main__':p=ProcessPoolExecutor(4)objs=[]
for i in range(10):# res=p.submit(piao,'alex %s' %i,i).result() #同步调用# print(res)obj=p.submit(piao,'alex %s' %i,i) #异步调用
        objs.append(obj)for obj in objs:print(obj.result())# 关门+等# pool.close()# pool.join()p.shutdown(wait=True)print('',os.getpid())

******

from concurrent.futures import ProcessPoolExecutor
import time, random, osdef piao(name, n):print('%s is piaoing %s' % (name, os.getpid()))time.sleep(1)return n ** 2if __name__ == '__main__':p = ProcessPoolExecutor(4)objs = []start = time.time()for i in range(10):# res=p.submit(piao,'alex %s' %i,i).result() #同步调用# print(res)obj = p.submit(piao, 'alex %s' % i, i)  # 异步调用
        objs.append(obj)p.shutdown(wait=True)print('', os.getpid())for obj in objs:print(obj.result())stop = time.time()print(stop - start)

**

from concurrent.futures import ProcessPoolExecutor
import time,random,osdef piao(name):print('%s is piaoing %s' %(name,os.getpid()))time.sleep(random.randint(1,4))if __name__ == '__main__':p=ProcessPoolExecutor(4)for i in range(10):p.submit(piao,'alex %s' %i)p.shutdown(wait=True)  # shutdown 关门  wait=True 等print('',os.getpid())

 

转载于:https://www.cnblogs.com/jassin-du/p/7921296.html

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

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

相关文章

xamarin怎么调用java的_XamarinSQLite教程在Xamarin.Android项目中使用数据库

XamarinSQLite教程在Xamarin.Android项目中使用数据库在Xamarin.Android项目中使用预设数据库的具体操作步骤如下:(1)创建一个Xamarin.Android项目,如AndroidSQLiteDemo。(2)在AndroidSQLiteDemo项目的Resources文件夹下创建一个Raw文件夹。(3)将上一节中…

服务框架及服务治理组件——业界调研

声明:主要内容来自公司内部 对业界的调研,不一定恰当、准确、实时。 表格文字较多,APP阅读体验较差 团队服务相关组件\方案通信框架监控负载均衡\路由是否开源腾讯完全自研;BG内部自治,每个BG有自己相应的解决方案,单独…

Swift快速入门(一)第一个Swift程序

1. 本系列说明 本系列只是一个Swift快速入门的教程,并没有详尽的介绍Swift,Swift也并不是一个简单的编程语言,所以要想详尽的系统的学习Swift,本系列并不适合你,此系列只是让开发者可以快速的用Swift来进行开发。另外学…

Scala学习之爬豆瓣电影

简单使用Scala和Jsoup对豆瓣电影进行爬虫,技术比較简单易学。写文章不易,欢迎大家採我的文章,以及给出实用的评论,当然大家也能够关注一下我的github;多谢。 1、爬虫前期准备 找好须要抓取的链接:https://m…

[JMX一步步来] 9、基于JBoss来写MBean

前面都是用JDK自带的JMX实现来写的MBean,JMX的实现不独SUN一家,JBOSS也有自己的JMX实现。如果你使用JBOSS来做WEB服务器,那么基于JBOSS的实现来写MBean,是一个不错的选择。象我们公司就是用JBOSS的,因此所有MBean都是基…

一个漂亮的输出MySql数据库表结构的PHP页面

经常为了方便和直观,我们会首先直接在数据库中设计出表,但是接下来又要将表的结构和设计编写在设计文档中,以便编码的时候可以直观的查询,一旦数据库表非常多,字段非常多的时候,这无疑是件非常郁闷的工作。…

java 属于以下哪种语言_Java属于以下哪种语言?( )

对于宝来(Bora2004)轿车EPS系统,属于当转向扭矩传感器G269发生故障时,只需单独更换转向扭矩传感器就行了。一般说来,下语可以根据下列因素判断趋势线的有效性 ( )。关于股价的移动规律,属于下列论述不正确的是( )。如果希望预测未…

C#设计模式(19)——状态者模式(State Pattern)

原文:C#设计模式(19)——状态者模式(State Pattern)一、引言 在上一篇文章介绍到可以使用状态者模式和观察者模式来解决中介者模式存在的问题,在本文中将首先通过一个银行账户的例子来解释状态者模式,通过这个例子使大家可以对状态…

如何规范 CSS 的命名和书写

我开始学前端的时候也是对于规范问题头疼,后来看了网易的NEC规范,惊呼牛逼 NEC : 更好的CSS样式解决方案 只遵循横向顺序即可,先显示定位布局类属性,后盒模型等自身属性,最后是文本类及修饰类属性。 →显示属性自身属性…

《学做程序经理》完整版

文/Joel Spolsky 译/罗小平 指派一名优秀的程序经理,是团队产出优秀软件的重要前提之一。你的团队里可能没有这样的人,其实绝大多数团队都没有。 Charles Simonyi,这位曾与MarthaStewart(译者注:美国女富豪&#…

java工程mvn引用jar_maven 项目加载本地JAR

将jar安装到本地的maven仓库1.首先确定本地有maven环境。2.安装本地jar模板:mvn install:install-file -Dfile -DgroupId -DartifactId -Dversion -Dpackaging示例:mvn install:install-file -DfileF:\jave-ffmpegjave-1.0.2.jar -DgroupIdffmpegjave -D…

优秀的软件企业为何倒下?

最近不到一个月,就看到两家著名公司——SUN公司和Borland公司相继被收购,引起IT界不小的震动,让人感慨万分。在此之前有北电(Nortel)、摩托罗拉的衰退,再往前有 美国数字设备公司Digital(Digita…

kafka exporter v0.3.0 发布: Prometheus官方推荐,欢迎试用

2019独角兽企业重金招聘Python工程师标准>>> 时隔1个半月,kakfa exporter v0.3.0于今日正式发布,欢迎大家试用。 项目地址 Github: https://github.com/danielqsj/kafka_exporter Docker Hub: https://hub.docker.com/r/danielqsj/kafka-expo…

java手动切换成独立显卡_JAVA设计模式之调停者模式

在阎宏博士的《JAVA与模式》一书中开头是这样描述调停者(Mediator)模式的:调停者模式是对象的行为模式。调停者模式包装了一系列对象相互作用的方式,使得这些对象不必相互明显引用。从而使它们可以较松散地耦合。当这些对象中的某些对象之间的相互作用发…

Hadoop2.6.0完全分布式安装

1、修改主机名称 对master/slave1/slave2同时配置为Master/Slave1/Slave2 masterMaster:~$ sudo gedit /etc/hostname 上述3个虚机结点均需要进行以上步骤 2、填写主机IP 对master/slave1/slave2同时配置 masterMaster:~$ sudo gedit /etc/hosts 192.168.48.128 master192.168.…

DEX加密效果分析

dex加密目的:保护安卓应用的Java源代码,避免被恶意分析,技术被窃取准备工具:1、apktool :反编译apk,提取smali代码2、dex2jar :将dex转化为jar文件3、jd-gui :查看jar文件&#xff0…

kd树的原理

kd树就是一种对k维空间中的实例点进行存储以便对其进行快速检索的树形数据结构,可以运用在k近邻法中,实现快速k近邻搜索。构造kd树相当于不断地用垂直于坐标轴的超平面将k维空间切分。    假设数据集\(T\)的大小是\(m*n\),即\(T{x_1,x_2,...x_m}\),其中…

力软 java主从表保存_JAVA常用知识总结(十二)——数据库(二)

MySQL主从热备份工作原理简单的说:就是主服务器上执行过的sql语句会保存在binLog里面,别的从服务器把他同步过来,然后重复执行一遍,那么它们就能一直同步啦。整体上来说,复制有3个步骤:作为主服务器的Maste…

Java——线程的创建,线程池

线程 多线程就是一个程序中有多个线程在同时执行。 多线程下CPU的工作原理 实际上,CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言,某个时刻,只能执行一个线程,而CPU的在多个线程间切换速度…

java并查集找朋友圈_图—并查集(解决朋友圈问题)

图也是一种 非线性结构,是由多个顶点组成的关系集合组成的一种数据结构。图可以分为两种,无向图和有向图。★图的定义:★典型问题:利用图能够解决很多问题,这里有一个较为典型的问题,假如已知有n个人和m对好友关系(存于…