python进程和线程

---恢复内容开始---

进程是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程可以完成那些功能以及如何完成；数据集则是程序在执行过程中所需要的使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标识。

进程是系统资源管理单位，线程是系统最小执行单位。线程的创建消耗远比进程的创建消耗小的多。

线程是为了降低上下文的消耗，提高系统的并发性，突破一个进程只能干一件事的缺陷，使进程内并发成为可能。

进程和线程的关系：

1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程

2、资源分配给进程，同一进程的所有线程共享该进程的所有资源

3、CPU分给线程，即真正在CPU上运行的是线程

并行处理是计算机系统中能同时执行两个或更多个处理的一种计算方法。并行处理可同时工作于同一程序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间。并发处理：指一个时间段中有几个程序都处于启动运行到运行完毕之间，且这几个程序都是在同一CPU上运行，但任一个时间点上只有一个程序在CPU上运行

并发的关键在于有多任务处理的能力，不一定要同时。并行的关键是你有同时处理多个任务的能力。所以，并行是并发的子集

同步：同步是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到信息才继续执行下去

异步：异步是指进程不需要一直等待下去，而是继续执行下面的操作，不管进程的其他状态，当有信息返回时系统会通知进程进行处理，这样可以提高执行的效率

threading模块

import threading,time

def foo(n):
    print(n)
    time.sleep(10)

def foo2(n):
    print(n)
    time.sleep(12)

s=time.time()
s=time.time()

t1=threading.Thread(target=foo,args=(10,))
t1.start()

t2=threading.Thread(target=foo2,args=(11,))
t2.start()

print('ending')
print(time.time()-s)
执行结果
10
11
ending
0.002009153366088867
程序会在12秒之后终止

import threading,time

def foo(n):
    print(n)
    time.sleep(10)

def foo2(n):
    print(n)
    time.sleep(12)

s=time.time()
s=time.time()

t1=threading.Thread(target=foo,args=(10,))
t1.start()

t2=threading.Thread(target=foo2,args=(11,))
t2.start()

t1.join()
t2.join()

print('ending')
print(time.time()-s)
执行结果
10
11
ending
12.004042148590088
程序会等待子进程结束后主进程结束

import threading,time

def foo(n):
    print(n)
    time.sleep(10)
    print('aiyaya')

def foo2(n):
    print(n)
    time.sleep(12)
    print('hahahaha')

s=time.time()

t1=threading.Thread(target=foo,args=(10,))
t1.setDaemon(True)
t1.start()

t2=threading.Thread(target=foo2,args=(11,))
# t2.setDaemon(True)
t2.start()

print('ending')
print(time.time()-s)
执行结果
10
11
ending
0.0005018711090087891
aiyaya
hahahaha

将线程声明为守护线程，必须在start()方法调用之前设置，如果不设置为守护线程程序会被无限挂起。当我们在程序运行中，执行一个主线程，如果主线程又创建了一个子线程，主线程和子线程分别运行，当主线程完成时，会检验子线程是否完成，主线程会等待子线程完成后退出。但是有时候我们需要的只是主线程完成了，不管子线程是否完成，都要和主线程一起退出，此时就需要setDaemon方法

import threading,time

def foo(n):
    print('foo...',n)
    print('activecount',threading.active_count())
    time.sleep(10)
    print('aiyaya')

def foo2(n):
    print('foo2...',n)
    time.sleep(12)
    print('hahahaha')

s=time.time()

t1=threading.Thread(target=foo,args=(10,))
t1.start()

t2=threading.Thread(target=foo2,args=(11,))
t2.start()

print('ending')
print(threading.active_count())
print(time.time()-s)
执行结果
foo... 10
activecount 3
foo2... 11
ending
3
0.0009839534759521484
aiyaya
hahahaha

thread实例对象的方法：

isAlive()：返回县城是否活动

getName()：返回线程名

setName()：设置线程名

threading模块提供的一些方法

threading.currentThread()：返回当前的现成变量

threading.enumerate()：返回一个包含正在运行的线程的list

threading.activeCount()：返回正在运行的线程数量，与len(threading.enumerate())结果相同

Thread类继承创建方法

import time,threading


class Mythread(threading.Thread):
    def __init__(self):

        threading.Thread.__init__(self)

    def run(self):
        print('haha')
        time.sleep(2)
        print('endinggggggg')


t1=Mythread()
t1.start()
print('ending')
执行结果
haha
ending
endinggggggg

 

在python中无论启动多少个线程，由于GIL锁（黄色部分）的存在，在执行一个进程的时候只会运行一个线程。所以，python对于计算密集型开启多线程会效率低，而对于IO密集型却有提升

不加锁的情形

import time,threading

def sub():
    global num
    # lock.acquire()
    temp=num
    time.sleep(0.1)
    num=temp-1
    # lock.release()
    time.sleep(2)

s=time.time()
num=100
l=[]
# lock=threading.Lock()
for i in range(100):
    t=threading.Thread(target=sub,args=())
    t.start()
    l.append(t)

for t in l:
    t.join()

print(num)

print('cost time %s'%(time.time()-s))
执行结果
99
cost time 2.1110031604766846

加锁后

import time,threading

def sub():
    global num
    lock.acquire()
    temp=num
    time.sleep(0.1)
    num=temp-1
    lock.release()
    time.sleep(2)

s=time.time()
num=100
l=[]
lock=threading.Lock()
for i in range(100):
    t=threading.Thread(target=sub,args=())
    t.start()
    l.append(t)

for t in l:
    t.join()

print(num)

print('cost time %s'%(time.time()-s))
执行结果
0
cost time 12.054694652557373

为什么GIL存在下还需要加锁？

因为多线程环境下存在资源的竞争，为了保证同一时刻只有一个线程对共享资源进行存取就需要加锁保证存取操作的唯一性，从而保证同一时刻只有一个线程共享数据存取

死锁：

import threading

class Mythread(threading.Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        self.foo()
        self.bar()

    def foo(self):
        locka.acquire()
        print('%s ha1ha2ha3 %s'%(self.name,time.ctime()))
        lockb.acquire()
        print('%s hahahaha %s'%(self.name,time.ctime()))
        lockb.release()
        locka.release()

    def bar(self):
        lockb.acquire()
        print('%s la1la2la3 %s'%(self.name,time.ctime()))
        locka.acquire()
        print('%s lalalala %s '%(self.name,time.ctime()))
        locka.release()
        lockb.release()

locka=threading.Lock()
lockb=threading.Lock()
l=[]

for i in range(10):
    t=Mythread()
    t.start()
    l.append(t)

for j in l:
    j.join()
执行结果
Thread-1 ha1ha2ha3 Tue Jul 18 19:08:18 2017
Thread-1 hahahaha Tue Jul 18 19:08:18 2017
Thread-1 la1la2la3 Tue Jul 18 19:08:18 2017
Thread-1 lalalala Tue Jul 18 19:08:18 2017 
Thread-2 ha1ha2ha3 Tue Jul 18 19:08:18 2017
Thread-2 hahahaha Tue Jul 18 19:08:18 2017
Thread-2 la1la2la3 Tue Jul 18 19:08:18 2017
Thread-3 ha1ha2ha3 Tue Jul 18 19:08:18 2017

递归锁：

import threading

class Mythread(threading.Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        self.foo()
        self.bar()

    def foo(self):
        Rlock.acquire()
        print('%s ha1ha2ha3 %s'%(self.name,time.ctime()))
        Rlock.acquire()
        print('%s hahahaha %s'%(self.name,time.ctime()))
        Rlock.release()
        Rlock.release()

    def bar(self):
        Rlock.acquire()
        print('%s la1la2la3 %s'%(self.name,time.ctime()))
        Rlock.acquire()
        print('%s lalalala %s '%(self.name,time.ctime()))
        Rlock.release()
        Rlock.release()

Rlock=threading.RLock()
l=[]

for i in range(10):
    t=Mythread()
    t.start()
    l.append(t)

for j in l:
    j.join()
执行结果
Thread-1 ha1ha2ha3 Tue Jul 18 19:09:28 2017
Thread-1 hahahaha Tue Jul 18 19:09:28 2017
Thread-1 la1la2la3 Tue Jul 18 19:09:28 2017
Thread-1 lalalala Tue Jul 18 19:09:28 2017 
Thread-2 ha1ha2ha3 Tue Jul 18 19:09:28 2017
Thread-2 hahahaha Tue Jul 18 19:09:28 2017
Thread-2 la1la2la3 Tue Jul 18 19:09:28 2017
Thread-2 lalalala Tue Jul 18 19:09:28 2017 
Thread-3 ha1ha2ha3 Tue Jul 18 19:09:28 2017
Thread-3 hahahaha Tue Jul 18 19:09:28 2017
Thread-3 la1la2la3 Tue Jul 18 19:09:28 2017
Thread-3 lalalala Tue Jul 18 19:09:28 2017 
Thread-4 ha1ha2ha3 Tue Jul 18 19:09:28 2017
Thread-4 hahahaha Tue Jul 18 19:09:28 2017
Thread-4 la1la2la3 Tue Jul 18 19:09:28 2017
Thread-4 lalalala Tue Jul 18 19:09:28 2017 
Thread-5 ha1ha2ha3 Tue Jul 18 19:09:28 2017
Thread-5 hahahaha Tue Jul 18 19:09:28 2017
Thread-5 la1la2la3 Tue Jul 18 19:09:28 2017
Thread-5 lalalala Tue Jul 18 19:09:28 2017 
Thread-6 ha1ha2ha3 Tue Jul 18 19:09:28 2017
Thread-6 hahahaha Tue Jul 18 19:09:28 2017
Thread-6 la1la2la3 Tue Jul 18 19:09:28 2017
Thread-6 lalalala Tue Jul 18 19:09:28 2017 
Thread-8 ha1ha2ha3 Tue Jul 18 19:09:28 2017
Thread-8 hahahaha Tue Jul 18 19:09:28 2017
Thread-8 la1la2la3 Tue Jul 18 19:09:28 2017
Thread-8 lalalala Tue Jul 18 19:09:28 2017 
Thread-9 ha1ha2ha3 Tue Jul 18 19:09:28 2017
Thread-9 hahahaha Tue Jul 18 19:09:28 2017
Thread-9 la1la2la3 Tue Jul 18 19:09:28 2017
Thread-9 lalalala Tue Jul 18 19:09:28 2017 
Thread-7 ha1ha2ha3 Tue Jul 18 19:09:28 2017
Thread-7 hahahaha Tue Jul 18 19:09:28 2017
Thread-7 la1la2la3 Tue Jul 18 19:09:28 2017
Thread-7 lalalala Tue Jul 18 19:09:28 2017 
Thread-10 ha1ha2ha3 Tue Jul 18 19:09:28 2017
Thread-10 hahahaha Tue Jul 18 19:09:28 2017
Thread-10 la1la2la3 Tue Jul 18 19:09:28 2017
Thread-10 lalalala Tue Jul 18 19:09:28 2017