并发编程——线程与进程，开启线程的两种方式，多线程与多进程

1 线程和进程

1、线程是一个基本的CPU执行单元，也是程序执行流的最小单元。
2、进程是拥有资源的基本单位，线程是独立调度的基本单位。
3、每启动一个进程，里面至少有一个线程，线程不拥有资源，但可以访问隶属于进程的系统资源。
4、创建或撤销进程（系统要为其分配或回收内存空间和资源），进程的切换，开销远大于线程。
5、同一进程内的多个线程共享进程的地址空间，共享进程的资源，线程之间通信容易实现。
6、进程内的线程对于其他进程不可见。

2 开启线程的两种方式threading模块，与进程方法类似

2.1 方式一：

from threading import Thread
import time

def test(name):
    print('%s is running' % name)
    time.sleep(2)
    print('%s is done' % name)

if __name__ =='__main__':
    t1 = Thread(target=test,args=('小明',))
    t1.start()
    print('主')
    
# 小明 is running
# 主
# 小明 is done

2.2 方式二：

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

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


if __name__ == '__main__':
    t1 = MyTest('小明')
    t1.start()
    print('主线程')


小明 is running
主线程
小明 is done

3 多线程与多进程的区别

3.1 进程开销大于线程

 def test():
    print('running')

if __name__ == '__main__':
    p1 = Process(target=test)
    p1.start()
    print('主进程')
    
# 主进程
# running

def test():
    print('running')


if __name__ == '__main__':
    t1 = Thread(target=test)
    t1.start()
    print('主线程')
    
# running
# 主线程

3.2 同一进程内的线程共享数据，进程之间数据隔离

def test():
    global n
    print('running')
    n = 0
    print('进程内：', n)


if __name__ == '__main__':
    n = 10
    p1 = Process(target=test)
    p1.start()
    p1.join()
    print('主进程:', n)
    
# running
# 进程内： 0
# 主进程: 10

def test():
    global n
    print('running')
    n = 0
    print('线程内：', n)


if __name__ == '__main__':
    n = 10
    t1 = Thread(target=test)
    t1.start()
    t1.join()
    print('主线程:', n)

# running
# 线程内： 0
# 主线程: 0

3.3 同一进程内线程pid一样，进程与进程的pid不一样

import os
import threading
import multiprocessing


def test():
    print('hello', '%s pid:' % threading.current_thread().getName(), os.getpid())


if __name__ == '__main__':
    t1 = Thread(target=test)
    t2 = Thread(target=test)
    t3 = Thread(target=test)
    t1.start()
    t2.start()
    t3.start()
    print('主线程:', os.getpid())
    
# hello Thread-1 pid: 26308
# hello Thread-2 pid: 26308
# hello Thread-3 pid: 26308
# 主线程: 26308

import os
import threading
import multiprocessing


def test():
    print('hello', '%s pid:' % multiprocessing.current_process().name, os.getpid())


if __name__ == '__main__':
    p1 = Process(target=test, name='p1')
    p2 = Process(target=test, name='p2')
    p3 = Process(target=test, name='p3')
    p1.start()
    p2.start()
    p3.start()
    print('主进程:', os.getpid())


# 主进程: 12516
# hello p1 pid: 46720
# hello p2 pid: 7540
# hello p3 pid: 29876
 

4 Thread对象其他属性或方法

Thread 对象的方法：

isAlive() :返回True or False 表示线程是否活动
getName():返回线程名
setName():设置线程名
join（）：等待线程运行结束

threading模块提供的方法：

threading.currentThead() ：返回当前线程
threading.enumerate()：返回正在运行的线程列表
threading.active_Count()：返回正在运行的线程数

from threading import Thread, currentThread


def test():
    print('%s is running' % currentThread().getName())  # 打印当前线程名
    time.sleep(3)


if __name__ == '__main__':
    t1 = Thread(target=test)
    t2 = Thread(target=test)
    t1.start()
    t2.start()
    print(threading.enumerate())
    print(threading.active_count())
    print('主线程')

# Thread-1 is running
# Thread-2 is running
# [<_MainThread(MainThread, started 12992)>, <Thread(Thread-1, started 12680)>, <Thread(Thread-2, started 42892)>]
# 3
# 主线程

from threading import Thread, currentThread


def test():
    print('%s is running' % currentThread().getName())  # 打印当前线程名
    time.sleep(3)
    print('done')


if __name__ == '__main__':
    t1 = Thread(target=test)
    t1.setName('线程t1')
    t1.start()
    t1.join()
    print('主线程')
    
# 线程t1 is running
# done
# 主线程

def test():
    print('%s is running' % currentThread().getName())  # 打印当前线程名
    time.sleep(3)
    print('done')


if __name__ == '__main__':
    t1 = Thread(target=test)
    t1.start()
    print(t1.is_alive())
    print('主线程')
    
# Thread-1 is running
# True
# 主线程
# done