进程_线程 之(二) --- 进程线程

进程　　

• 单任务[单进程]

 1 from time import sleep
 2 
 3 def func():
 4     print("你好，我也是单任务")
 5 
 6 if __name__ == '__main__':
 7     while True:
 8         print("你好我是单任务")
 9         sleep(2)
10     func()
11 
12 # ------------------输出结果：一条一条输出--------------------

• 多进程多任务

from time import sleep
from multiprocessing import Process # 导入系统的进程对象
import os # 导入操作系统

def func(string):
    while True:
        print("我是---子进程，我的id是：",os.getpid())
        sleep(2)

# 这个程序运行起来操作系统会给他创建一个主进程
if __name__ == '__main__':
    # 创建一个进程对象,并且把func函数绑定到进程对象，
    # 进程名被命名为：“hello”。这个进程是在主进程创建完以后创建的子进程。
    p = Process(target=func,args=("hello",))
    p.start() # 开启进程

    while True:
        print("我是---主进程，我的id是：",os.getpid())
        sleep(2)

# ---------------输出时：子进程和主进程同时进行输出-------------------

•  多线程

 1 import threading
 2 from time import sleep
 3 
 4 def func(s):
 5     while True:
 6         print("我是子线程-",threading.current_thread().name,s)
 7         sleep(1)
 8 if __name__ == '__main__':
 9 
10     # 创建一个子线程对象
11     t = threading.Thread(target=func,name="func线程",args=("OK!",))
12     t.start()  # 开启这个子线程
13     while True:
14         # 获取并打印主线程名字
15         print("我是主线程，我的名字为：",threading.current_thread().name)
16         sleep(1)
17 
18 
19 # ----------- 主线程和子线程并发执行------------------

---

 线程

---

线程的创建

1 import threading  # 线程模块
2 from time import sleep
3 import _thread # 此模块用于给线程加守护

• 方法一：守护线程 [主线程死到后，子线程也会死掉]

 1 # 定义一个方法--子线程，用于绑定线程
 2 def run(arg):
 3     # 线程名
 4     name = threading.current_thread().name
 5     print("子---线程名为：",name)
 6     for i in range(1,9):
 7         print("子线程%s执行了%d次循环"%(threading.current_thread().name,i))
 8         sleep(2)
 9 
10 # 创建方式一、守护线程
11 def thread1():
12     # 使用守护方式创建一个子线程,守护线程不需要手动开启，绑定后自动就会开启。
13     # 此时的代码是在主线程中运行的，当主线程死掉子线程也会死掉
14     _thread.start_new_thread(run,("MrGuo",))
15     # 获取主线程的name
16     name = threading.current_thread().name
17     print("主---线程名为：",name)
18     for i in range(1,5):
19         print("主线程%s执行了%d次循环"%(name,i))
20         sleep(1)

 1 # 结果,主线程死掉后，子线程也同时死到。Dummpy傀儡
 2 """
 3 　　主---线程名为： MainThread
 4 　　子---线程名为： Dummy-1
 5 　　子线程Dummy-1执行了1次循环
 6 　　主线程MainThread执行了1次循环
 7 　　主线程MainThread执行了2次循环
 8 　　子线程Dummy-1执行了2次循环
 9 　　主线程MainThread执行了3次循环
10 　　主线程MainThread执行了4次循环
11 　　子线程Dummy-1执行了3次循环
12 """

• 方法二：非守护线程

 1 # 定义一个方法--子线程，用于绑定线程
 2 def run(arg):
 3     # 线程名
 4     name = threading.current_thread().name
 5     print("子---线程名为：",name)
 6     for i in range(1,7):
 7         print("子线程%s执行了%d次循环"%(threading.current_thread().name,i))
 8         sleep(2)
 9 
10 # 创建方式二、非守护线程
11 def thread2():
12     # 采用非守护的方式来创建线程。 主线程死掉后，子线程不受影响
13     t = threading.Thread(target=run,args=("Ya",))
14     t.start()
15     # 获取主线程的name
16     name = threading.current_thread().name
17     print("主---线程名为：", name)
18     for i in range(1, 4):
19         print("主线程%s执行了%d次循环" % (name, i))
20         sleep(1)
21 
22 if __name__ == '__main__':
23     thread2()

 1 # 结果，主线程死掉后，不影响子线程继续执行
 2 """
 3 　　子---线程名为： Thread-1
 4 　　主---线程名为： MainThread
 5 　　主线程MainThread执行了1次循环
 6 　　子线程Thread-1执行了1次循环
 7 　　主线程MainThread执行了2次循环
 8 　　子线程Thread-1执行了2次循环
 9 　　主线程MainThread执行了3次循环
10 　　子线程Thread-1执行了3次循环
11 　　子线程Thread-1执行了4次循环
12 　　子线程Thread-1执行了5次循环
13 　　子线程Thread-1执行了6次循环
14 """

• 方法三：自定义线程 [系统子进程方法重写]

 1 # 创建方式三、自定义线程
 2 # 自定义个线程类，继承自threading.Thread，变成其子类
 3 class MyThead(threading.Thread):
 4     # 重写构造方法
 5     def __init__(self,name,task):
 6         super().__init__()
 7         self.name = name
 8         self.task = task
 9     # 重写run方法
10     def run(self):
11         # 线程类核心函数，这里就是线程功能
12         print("子---线程名为：",self.name,self.task)
13         for i in range(1, 9):
14             print("子线程%s执行了%d次循环" % (self.name, i))
15             sleep(2)
16 
17 def thread3():
18     t = MyThead("自定义子线程","Peng")
19     t.start()
20     # 获取主线程的name
21     name = threading.current_thread().name
22     print("主---线程名为：", name)
23     for i in range(1, 4):
24         print("主线程%s执行了%d次循环" % (name, i))
25         sleep(1)
26 
27 if __name__ == '__main__':
28     thread3()

 1 # 结果， 主进程死掉后，子进程不受影响
 2 """
 3 　　子---线程名为： 自定义子线程 Peng
 4 　　子线程自定义子线程执行了1次循环
 5 　　主---线程名为： MainThread
 6 　　主线程MainThread执行了1次循环
 7 　　主线程MainThread执行了2次循环
 8 　　子线程自定义子线程执行了2次循环
 9 　　主线程MainThread执行了3次循环
10 　　子线程自定义子线程执行了3次循环
11 　　子线程自定义子线程执行了4次循环
12 　　子线程自定义子线程执行了5次循环
13 　　子线程自定义子线程执行了6次循环
14 　　子线程自定义子线程执行了7次循环
15 　　子线程自定义子线程执行了8次循环
16 """

 

 

转载于:https://www.cnblogs.com/TMMM/p/10786688.html