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

灰太狼 2021-10-25 12:00 477阅读 0赞

## 进程　　 ##

*  **单任务\[单进程\]**

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