并发编程之线程多线程

Posted 2020-10-12

线程

开启线程的两种方法：

#方式一：
from threading import *
import os
def work():
    print(‘%s is working‘ % os.getpid())
if __name__ == ‘__main__‘:
    t = Thread (target=work)
    t.start()

方法1

#方式二：
class S_T(Thread ):
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        print(‘%s is working‘ % os.getpid(),self.name)
if __name__ == ‘__main__‘:
    s_t = S_T (1)
    s_t.start()

方法2

基于线程实现socket套接字并发

 

#_*_coding:utf-8_*_
#!/usr/bin/env python
import multiprocessing
import threading

import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind((‘127.0.0.1‘,8080))
s.listen(5)

def action(conn):
    while True:
        data=conn.recv(1024)
        print(data)
        conn.send(data.upper())

if __name__ == ‘__main__‘:

    while True:
        conn,addr=s.accept()


        p=threading.Thread(target=action,args=(conn,))
        p.start()

多线程并发的socket服务端

多线程实现并发服务端my_server.py

 

#_*_coding:utf-8_*_
#!/usr/bin/env python


import socket

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect((‘127.0.0.1‘,8080))

while True:
    msg=input(‘>>: ‘).strip()
    if not msg:continue

    s.send(msg.encode(‘utf-8‘))
    data=s.recv(1024)
    print(data)

客户端

多线程实现并发套接字客户端my_client.py

 

 

线程对象的其他方法：

 

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法：
  # threading.currentThread(): 返回当前的线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

方法们

 

from threading import Thread,current_thread,enumerate,activeCount
import os,time
n=100

def work():
    print(‘%s is ruuning‘ %current_thread().getName())
if __name__ == ‘__main__‘:
    t=Thread(target=work)
    t.start()
    # t.join()
    # print(t.is_alive())#返回线程是否活动的。
    # print(t.getName())#返回线程名。
    # print(current_thread().getName())#返回当前的线程变量。
    print(enumerate())#返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
    print(activeCount())#返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
    print(‘主线程‘,n)

线程对象的其他方法实例

 

守护线程：

无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁
需要强调的是：运行完毕并非终止运行

 

#1.对主进程来说，运行完毕指的是主进程代码运行完毕
#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，

#2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕
#2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

解释

 

#主线程从执行角度就代表类该进程，主线程会在所有非守护线程都运行完毕才结束，守护线程就在主线程结束后结束
# from threading import Thread,current_thread
# import time
# def work():
#     print(‘%s is runing‘ %current_thread().getName())
#     time.sleep(2)
#     print(‘%s is done‘ %current_thread().getName())
#
# if __name__ == ‘__main__‘:
#     t=Thread(target=work)
#     # t.daemon=True
#     t.start()
#     print(‘主‘)

from threading import Thread
import time
def foo():
    print(123)
    time.sleep(5)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == ‘__main__‘:

    t1=Thread(target=foo)
    t2=Thread(target=bar)

    t1.daemon=True
    t1.start()
    t2.start()
    print("main-------")

View Code

 

 

GIL全局解释器锁

是的，这个锁不与lock锁冲突，这个锁是在python解释器层面的，lock实在自己写的代码上的

 

启

 

 启启

启

启

启

启启

启

启

启

启

启

启

启

启