并发编程 - 多线程 - 总结

进程，线程：
    进程只是用来把资源集中到一起的（进程只是个资源单位，或者说资源集合），线程才是cpu上的执行单位。
    区别：
        1.同一个进程内的多个线程共享该进程内的地址资源
        2.创建线程的开销要远小于创建进程的开销（创建一个进程，就是创建一个车间，涉及到申请空间，而且在该空间内建至少一条流水线，但创建线程，就只是在一个车间内造一条流水线，无需申请空间，所以创建开销小

1.创建线程的两种方式：

import time
from threading import Thread

def sayhi(name):
    time.sleep(2)
    print('%s is say hello'%name)

if __name__ == "__main__":
    t = Thread(target=sayhi,kwargs={'name':'alice'})
    # t = Thread(target=sayhi,args=('alice',))
    t.start()

    print('主线程')

from threading import Thread
import time

class Sayhi(Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        time.sleep(2)
        print('%s is say hello'%self.name)

if __name__ == "__main__":
    t = Sayhi('alice')
    t.start()

    print('主线程')

2.多进程多线程的区别： 
    1.开进程的开销远大于开线程
    2.进程之间地址空间是隔离的，
      同一进程内开启的多个线程是共享该进程的地址空间的
    3.开多个进程，每个进程都有不同的pid
      在主进程下开启多个线程，每个线程的pid都和主进程的pid一样 

#1.
from multiprocessing import Process
from threading import Thread
import time

def work(name):
    print('%s is working'%name)
    time.sleep(2)
    print('%s is done'%name)

if __name__ == "__main__":
    # p = Process(target=work,args=('alice',))
    # p.start()

    t = Thread(target=work,args=('alice',))
    t.start()

    print('主进程/主线程')
"""
主进程/主线程
alice is working
alice is done
"""
"""
alice is working
主进程/主线程
alice is done
"""
#2.
from multiprocessing import Process
from threading import Thread

n=100
def task():
    global n
    n=0

if __name__ == "__main__":
    # p = Process(target=task)
    # p.start()
    # p.join()   # 彼此隔离的 n: 100
    t = Thread(target=task,)
    t.start()
    t.join()   # 共享地址空间 n: 0
    print('n:',n)
"""
n: 100
"""
"""
n: 0
"""
# 3.
from multiprocessing import Process,current_process
from threading import Thread
import os

def task():
    print(current_process().pid)
    print('hello,pid:',os.getpid(),"ppid:",os.getppid())

if __name__ == "__main__":
    p1 = Process(target=task)
    p2 = Process(target=task)
    p1.start()
    p2.start()
    # t1 = Thread(target=task)
    # t2 = Thread(target=task)
    # t1.start()
    # t2.start()

    print(current_process().pid)
    print('主进程/主线程 pid:',os.getpid(),'ppid:',os.getppid())
"""
主进程/主线程 pid: 6908 ppid: 3888
hello,pid: 21096 ppid: 6908
hello,pid: 20228 ppid: 6908
"""
"""
hello,pid: 24068 ppid: 3888
hello,pid: 24068 ppid: 3888
主进程/主线程 pid: 24068 ppid: 3888
"""

3.Thread对象的其他属性或方法：
    Thread实例化对象的方法：
        1.t.isAlive() / t.is_alive()  # 返回线程是否活动中
        2.t.getName() / t.name        # 返回线程名
        3.t.setName()                 # 设置线程名
    threading模块提供的一些方法：
        threading.currentThread()     # 返回当前的线程变量
        threading.enumerate()         # 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
        threading.activeCount()       # 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
    主线程等待子线程结束！！

from threading import Thread,currentThread,current_thread,active_count,enumerate,activeCount
import time

def task():
    print('%s is running'%currentThread().getName())
    time.sleep(2)
    print('%s is done'%current_thread().getName())

if __name__ == "__main__":
    t = Thread(target=task,)
    t.start()
    # t.join()
    print(t.getName())
    t.setName('儿子')
    print(t.name)
    currentThread().setName('主线程')
    print(current_thread().name)
    print(t.is_alive())
    # t.join()
    print(active_count())
    print(enumerate())
    print(t.isAlive())
    print(t.name)
    print(t.getName())
    # currentThread().
    print(len(enumerate()))
    print(activeCount())
    print(active_count())
    # t.join()
    print(t.isAlive())
    time.sleep(3)
    print(t.isAlive())

4.守护线程：
    守护进程（守护线程）会等待主进程（主线程）运行完毕后被销毁
    运行完毕并非终止运行：
        1.对主进程来说：运行完毕指的是主进程代码运行完毕
        2.对主线程来说：运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕
    详细解释：
        1.主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束。
        2.主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

    t.daemon = True
    t.setDaemon(True) 

from threading import Thread
import time

def sayhi(name):
    print('start-------')
    time.sleep(2)
    print('%s say hello'%name)

if __name__ == "__main__":
    t = Thread(target=sayhi,args=('alice',))
    # t.daemon = True
    t.setDaemon(True)
    t.start()

    print('主线程')
    print(t.is_alive())
"""
start-------
主线程
True
"""

# 思考下述代码的执行结果有可能是哪些情况？为什么？
from threading import Thread
import time

def foo():
    print(123)
    time.sleep(1)
    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-------")
"""   # 主线程运行完毕 指的是 所有的非守护线程统统运行完毕
123
456
main-------
end123
end456
"""