线程基础和用法

时间  2019-12-19
标签 线程 基础 用法 繁體版
原文   原文链接

目录python

1、线程

  1. 初识线程
    在传统操做系统种，每一个进程有一个地址空间，并且默认就有一个控制线程，cpu真正的执行单位是线程。
    在工厂中，每个车间都有房子，并且每一个车间默认就有一个流水线。程序员

  2. 作一个比较操作系统

    ​ 至关于
    操做系统------->工厂
    进程------->车间
    线程------->流水线
    cpu------->电源线程

  3. 线程：cpu最小的执行单位
    进程：资源集合/资源单位
    线程运行 ------->代码运行
    进程运行------->各类资源 + 线程code

  4. 右键运行会发生的事情：申请内存空间，先将解释器代码丢进去而且把python代码丢进去（进程作的）（内存运行的时候不识别python文件代码，只有解释器才能识别python文件代码，全部先把解释器放入内存），运行代码（线程）对象

  5. 进程和线程的区别：
    过程描述的区别
    线程------->单指代码的执行过程
    进程------->资源的申请与销毁的过程进程

  6. 进程内存空间彼此隔离（内存共享or隔离）ip

    多个进程内存空间彼此隔离。内存

    同一进程下的多个线程共享该进程内的数据。同一个进程下的线程共享资源资源

  7. 进程和线程的创造速度
    进程须要申请资源开辟空间------->慢
    只是告诉操做系统一个执行方案------->快

  8. 1 进程的启动和销毁（空间开始和释放）

    只要一说一个进程启动了，那你知道了一个事情，是关于这个程序的一块空间造好了。

    只要一说进程销毁了，那你也知道了一个事情，是关于这个程序的空间释放了。

    2 线程的启动和销毁（进程里的一段代码运行起来了，进程里的一段代码运行结束）

  9. 进程之间是竞争关系，线程之间是协做关系？（了解）

    车间直接是竞争/抢电源的关系，竞争（不一样的进程直接是竞争关系，是不一样的程序员写的程序运行的，迅雷抢占其余进程的网速，360把其余进程当作病毒干死）
    一个车间的不一样流水线式协同工做的关系（同一个进程的线程之间是合做关系，是同一个程序写的程序内开启动，迅雷内的线程是合做关系，不会本身干本身）

2、开启线程的俩种方式

因为线程开启不会出现一直循环调用开启的状况和进程是不一样的，因此不须要用main来隔绝，但能够使用。

2.1方式1

from threading import Thread
import time
def task():
    print('线程 start')
    time.sleep(2)
    print('线程end')
if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    print('主进程')
################
线程 start
主进程
线程end

2.2方式2

from threading import Thread
import time
class Myt(Thread):
    def run(self):
        print('子进程 start')
        time.sleep(2)
        print('子进程 end')
t = Myt()
t.start()
print('主')
#######################
子进程 start
主
子进程 end

3、子进程vs子线程建立速度

from threading import Thread
from multiprocessing import Process
import time


def task(name):
    print(f'{name} is runing')
    time.sleep(2)
    print(f'{name} is endding')


if __name__ == '__main__':
    t= Thread(target=task,args=('子线程',))
    p = Process(target=task,args=('子进程',))
    t.start()
    p.start()
    print('主')
##########################
子线程 is runing
主
子进程 is runing
子线程 is endding
子进程 is endding
from threading import Thread
from multiprocessing import Process
import time


def task(name):
    print(f'{name} is runing')
    time.sleep(2)
    print(f'{name} is endding')


if __name__ == '__main__':
    t= Thread(target=task,args=('子线程',))
    # p = Process(target=task,args=('子进程',))
    t.start()
    # p.start()
    print('主')
#######################
子线程 is runing
主
子线程 is endding
from threading import Thread
from multiprocessing import Process
import time


def task(name):
    print(f'{name} is runing')
    time.sleep(2)
    print(f'{name} is endding')


if __name__ == '__main__':
    # t= Thread(target=task,args=('子线程',))
    p = Process(target=task,args=('子进程',))
    # t.start()
    p.start()
    print('主')
##################
主
子进程 is runing
子进程 is endding

4、子线程共享资源

from threading import Thread
import time,os
x = 100
def task():
    global x
    x = 50
    print(os.getpid())
if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    time.sleep(2)
    print(x)
    print(os.getpid())#处于一个进程，因此pid是同样的
###########
16656
50
16656

5、线程的jion方法

5.1方法1

from threading import Thread
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程 end')
t = Thread(target=task)
t.start()
t.join()#等待子线程运行结束
print('主线程')
################
子线程 start
子线程 end
主线程

思考主线程是否会等子线程运行结束

1 实际上是进程在等
貌似是主线程在原地等着，主线程已经运行完。
原来没有子线程的状况下，其实就一个主线程这一条流水线工做完了，这个进程就结束了。
那如今的状况是当前进程有其余的子线程，是进程等待本身全部的子线程运行完。

# 主进程等子进程是由于主进程要给子进程收尸
# 如今看到的等是进程必须等待其内部全部线程都运行完毕才结束。

5.2方法2

from threading import Thread
import time
def task(name,n):
    print(f'{name} start')
    time.sleep(n)
    print(f'{name} end')
t1 = Thread(target=task,args=('线程1',1))
t2 = Thread(target=task,args=('线程2',2))
t3 = Thread(target=task,args=('线程3',3))
start = time.time()
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
end = time.time()
print(end-start)
##########################
线程1 start
线程2 start
线程3 start
线程1 end
线程2 end
线程3 end
3.0029337406158447

5.3了解进程的jion

from multiprocessing import Process
from threading import Thread

import time
def task():
    print('进程 start')
    time.sleep(10)
    print('进程  end')
def task2():
    print('子线程 start')
    time.sleep(3)
    print('子线程 end')
if __name__ == '__main__':
    p = Process(target=task)
    t = Thread(target=task2)
    t.start()
    p.start()
    print('子进程的join开始')
    p.join()#主进程的主线程等待子进程运行结束
    print('主')
##################
子线程 start
子进程的join开始
进程 start
子线程 end
进程  end
主

6、守护线程

# 守护线程首先是一个线程。
    # 守护线程守护到当前进程运行结束。
    # ps:好比有未完成的子进程阶段会守护，好比有未完成的其余子线程也均会守护。
# 守护进程首先是一个进程。
    # 守护进程守护到当前进程的最后一行代码结束。
from threading import Thread,enumerate,currentThread
import time
def task():
    print('守护线程开始')
    print(currentThread())
    time.sleep(10)
    print('守护线程end')
def task2():
    print('子线程 start')
    time.sleep(5)
    print(enumerate())
    print('子线程 end')
if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task2)
    t1.daemon = True
    t2.start()
    t1.start()
    print('主')
####################
子线程 start
守护线程开始
<Thread(Thread-1, started daemon 13904)>
主
[<_MainThread(MainThread, stopped 13828)>, <Thread(Thread-2, started 3316)>, <Thread(Thread-1, started daemon 13904)>]
子线程 end

7、线程其余的相关用法

Thread实例对象的方法

  1. isAlive(): 返回线程是否活动的。
  2. getName(): 返回线程名。
  3. setName(): 设置线程名。

threading模块提供的一些方法：

  1. threading.currentThread(): 返回当前的线程变量。
  2. threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  3. threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果

  • isalive()

    from threading import Thread,currentThread,enumerate,activeCount
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程  end')
if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task)
    t1.start()
    t2.start()


    print(t1.is_alive())#子线程存在，True
#################
子线程 start
子线程 start
True
子线程  end
子线程  end

  • getname()

    from threading import Thread,currentThread,enumerate,activeCount
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程  end')
if __name__ == '__main__':
    t1 = Thread(target=task)
    t1.start()


    print(t1.getName())

##########################
子线程 start
Thread-1
子线程  end

  • setname()

    from threading import Thread,currentThread,enumerate,activeCount
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程  end')
if __name__ == '__main__':
    t1 = Thread(target=task)
    t1.start()

    t1.setName('线程1')
    print(t1.getName())
#####################
子线程 start
线程1
子线程  end

  • currentTread()

    •  
 
  • enumerate()
     
    from threading import Thread,currentThread,enumerate,activeCount
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程  end')
    print(enumerate())
if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task)
    t1.start()
    t2.start()
###################################
子线程 start
子线程 start
子线程  end
[<_MainThread(MainThread, stopped 12328)>, <Thread(Thread-1, started 6176)>, <Thread(Thread-2, started 14452)>]
子线程  end
[<_MainThread(MainThread, stopped 12328)>, <Thread(Thread-2, started 14452)>]
     
    from threading import Thread,currentThread,enumerate,activeCount
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程  end')
if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task)
    t1.start()
    t2.start()
    print(enumerate())
########################
子线程 start
子线程 start
[<_MainThread(MainThread, started 16964)>, <Thread(Thread-1, started 15796)>, <Thread(Thread-2, started 15476)>]
子线程  end
子线程  end
    •  
 
  • activeCount()与len(enumerate())
     
    from threading import Thread,currentThread,enumerate,activeCount
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程  end')
if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task)
    t1.start()
    t2.start()
    print(activeCount())
    print(len(enumerate()))
#################
子线程 start
子线程 start
3
3
子线程  end
子线程  end
    •  
 
  • 1
     
    from threading import Thread,currentThread,enumerate,activeCount
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程  end')
if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task)
    t1.start()
    t2.start()
    print(currentThread())
    print(currentThread().name)
##################
子线程 start
子线程 start
<_MainThread(MainThread, started 2696)>
MainThread
子线程  end
子线程  end
    •  



        

            

        	





    

		

            
相关文章

            

                

                

                    

                

            


            
相关标签/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公众号
    

    

           欢迎关注本站公众号,获取更多信息

        
    




    

    




	


	







    

        联系我们
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程