Python中进程如果任务return输出该怎么办

1.什么是进程

程序仅仅只是一堆代码而已，而进程指的是程序的运行过程。需要强调的是：同一个程序执行两次，那也是两个进程。

进程：资源管理单位（容器）。

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

---

2.什么是线程

线程：最小执行单位，管理线程的是进程。

线程的出现是为了降低上下文切换的消耗，提高系统的并发性，并突破一个进程只能干一样事的缺陷，使到进程内并发成为可能。假设，一个文本程序，需要接受键盘输入，将内容显示在屏幕上，还需要保存信息到硬盘中。若只有一个进程，势必造成同一时间只能干一样事的尴尬（当保存时，就不能通过键盘输入内容）。若有多个进程，每个进程负责一个任务，进程A负责接收键盘输入的任务，进程B负责将内容显示在屏幕上的任务，进程C负责保存内容到硬盘中的任务。这里进程A，B，C间的协作涉及到了进程通信问题，而且有共同都需要拥有的东西——-文本内容，不停的切换造成性能上的损失。若有一种机制，可以使任务A，B，C共享资源，这样上下文切换所需要保存和恢复的内容就少了，同时又可以减少通信所带来的性能损耗，那就好了。是的，这种机制就是线程。
线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源。

---

3.进程与线程的关系

在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程。

多线程（即多个控制线程）的概念是，在一个进程中存在多个控制线程，控制该进程的地址空间。

进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。

进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。或者说进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。线程则是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。

进程和线程的关系：
(1)一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
(2)资源分配给进程，同一进程的所有线程共享该进程的所有资源。
(3)CPU分给线程，即真正在CPU上运行的是线程。

---

4.并行和并发

无论是并行还是并发，在用户看来都是’同时’运行的，而一个cpu同一时刻只能执行一个任务。
并行：同时运行，只有具备多个cpu才能实现并行。
并发：是伪并行，即看起来是同时运行，单个cpu+多道技术。

所有现代计算机经常会在同一时间做很多件事，一个用户的PC（无论是单cpu还是多cpu），都可以同时运行多个任务（一个任务可以理解为一个进程）。当启动系统时，会秘密启动许多进程比如：
启动一个进程来杀毒（360软件）
启动一个进程来看电影（暴风影音）
启动一个进程来聊天（腾讯QQ）
所有的这些进程都需被管理，于是一个支持多进程的多道程序系统是至关重要的。

多道技术：内存中同时存入多道（多个）程序，cpu从一个进程快速切换到另外一个，使每个进程各自运行几十或几百毫秒，这样，虽然在某一个瞬间，一个cpu只能执行一个任务，但在1秒内，cpu却可以运行多个进程，这就给人产生了并行的错觉，即伪并发，以此来区分多处理器操作系统的真正硬件并行（多个cpu共享同一个物理内存）。

---

5.线程的生命周期

所谓的xx生命周期，其实就是某对象的包含产生和销毁的一张状态图。线程的生命周期如下图所示：

各状态的说明如下：

New新建：新创建的线程经过初始化后，进入Runnable状态。

Runnable就绪：等待线程调度。调度后进入运行状态。

Running运行：执行代码方法体。

Blocked阻塞：暂停运行，解除阻塞后进入Runnable状态重新等待调度。

Dead消亡：线程方法执行完毕返回或者异常终止。

可能有3种情况从Running进入Blocked：
同步：线程中获取同步锁，但是资源已经被其他线程锁定时，进入Locked状态，直到该资源可获取（获取的顺序由Lock队列控制）
睡眠：线程运行sleep()或join()方法后，线程进入Sleeping状态。区别在于sleep等待固定的时间，而join是等待子线程执行完。sleep()确保先运行其他线程中的方法。当然join也可以指定一个“超时时间”。从语义上来说，如果两个线程a,b, 在a中调用b.join()，相当于合并(join)成一个线程。将会使主调线程(即a)堵塞(暂停运行, 不占用CPU资源), 直到被调用线程运行结束或超时, 参数timeout是一个数值类型，表示超时时间，如果未提供该参数，那么主调线程将一直堵塞到被调线程结束。最常见的情况是在主线程中join所有的子线程。
等待：线程中执行wait()方法后，线程进入Waiting状态，等待其他线程的通知(notify）。wait方法释放内部所占用的琐，同时线程被挂起，直至接收到通知被唤醒或超时（如果提供了timeout参数的话）。当线程被唤醒并重新占有琐的时候，程序才会继续执行下去。
**注意：**threading.Lock()不允许同一线程多次acquire(), 而RLock允许, 即多次出现acquire和release。

---

6.python的Threading模块

Threading用于提供线程相关的操作。

---

6.1Thread方法说明：

t.start() : 激活线程，
t.getName() : 获取线程的名称
t.setName() ： 设置线程的名称
: 获取或设置线程的名称
t.is_alive() ： 判断线程是否为激活状态
t.isAlive() ：判断线程是否为激活状态
t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之后才可以使用。如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
t.isDaemon() ： 判断是否为守护线程
t.ident ：获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None。
t.join() ：逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
t.run() ：线程被cpu调度后自动执行线程对象的run方法

---

6.2实现python多线程的两种方式
在Python中，有两种方式可以实现多线程：（1）函数方式 （2）重写threading类方法

（1）函数方式
基本语法为：start_new_thread ( function , args [ , kwargs ] )
　　创建一个新的线程，返回一个线程标识符。function是线程函数，args是线程函数的参数，是一个list。kwargs可选参数，可不填。

import threading
import time
def someting():
    for i in range(1,11):
        print(i)
        time.sleep(1)

threading._start_new_thread(someting(),())
print("main")
input()

注意：函数实现方式，线程必须依赖函数实现，不能单独运行。当函数结束，线程结束。所以如果想让线程一直运行，就要想办法让程序不结束，比如在程序最后加一个input(),或死循环。
（2）重写类方法
1.继承 threading.Thread
2.重写构造方法，且必须调用父类的构造方法
3.重写父类的run方法,会在start之后自动调用
4.实现开始方法，如果重写了start()方法，一定要调用父类的start()

import threading
import time
#继承threading类
class Mythread(threading.Thread):
    #重写构造方法
    def __init__(self, name):
        threading.Thread.__init__(self)
         = name
    #重写run方法
    def run(self):
        time.sleep(0.1)
        for i in range(0, 13):
            print("这是线程：{}，结果是{}".format(, i))

mythread1 = Mythread("线程1")
mythread2 = Mythread("线程2")
#调用start（）方法会默认调用重写的run方法
mythread1.start()
mythread2.start()

我们一般会使用第二种方式，也就是重写类方法。这种方式会更灵活。第一种方式不推荐使用。

---

6.3单线程实例：

# 导入模块
import time, threading

class TaskThread(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self, name=name)

    def run(self):
        print('thread %s is running...' % self.getName())
        for i in range(6):
            print('thread %s >>> %s' % (self.getName(), i))
            time.sleep(1)
        print('thread %s finished.' % self.getName())

taskthread = TaskThread('TaskThread')
taskthread.start()

运行结果为：

thread TaskThread is running…
thread TaskThread >>> 0
thread TaskThread >>> 1
thread TaskThread >>> 2
thread TaskThread >>> 3
thread TaskThread >>> 4
thread TaskThread >>> 5
thread TaskThread finished.

---

6.4线程锁threading.RLock和threading.Lock
由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，CPU接着执行其他线程。为了保证数据的准确性，引入了锁的概念。所以，可能出现如下问题：
例：假设列表A的所有元素就为0，当一个线程从前向后打印列表的所有元素，另外一个线程则从后向前修改列表的元素为1,那么输出的时候，列表的元素就会一部分为0，一部分为1,这就导致了数据的不一致。锁的出现解决了这个问题。

import threading
import time

globals_num = 0
 #实例化一个锁
lock = threading.Lock()

def Func():
    lock.acquire()  # 获得锁 
    global globals_num
    globals_num += 1
    time.sleep(1)
    print(globals_num)
    lock.release()  # 释放锁 

for i in range(10):
    t = threading.Thread(target=Func)
    t.start()

6.5 threading.RLock和threading.Lock 的区别：
RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。 如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。

所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

import threading
import time

mutexA = threading.Lock()
mutexB = threading.Lock()

class MyThread(threading.Thread):

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

    def run(self):
        self.fun1()
        self.fun2()

    def fun1(self):

        mutexA.acquire()  # 如果锁被占用,则阻塞在这里,等待锁的释放

        print ("I am %s , get res: %s---%s" %(, "ResA",time.time()))

        mutexB.acquire()
        print ("I am %s , get res: %s---%s" %(, "ResB",time.time()))
        mutexB.release()
        mutexA.release()


    def fun2(self):

        mutexB.acquire()
        print ("I am %s , get res: %s---%s" %(, "ResB",time.time()))
        time.sleep(0.2)

        mutexA.acquire()
        print ("I am %s , get res: %s---%s" %(, "ResA",time.time()))
        mutexA.release()

        mutexB.release()

if __name__ == "__main__":

    print("start---------------------------%s"%time.time())

    for i in range(0, 10):
        my_thread = MyThread()
        my_thread.start()

出现死锁不停竞争，程序卡住。
解决方法：
在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

rl = threading.RLock()  # 递归锁

rl.acquire()  # 上锁 计数+1 counter=1
rl.acquire()  # 上锁 计数+1 counter=2
...
rl.release()  # 解锁 计数-1 counter=1
rl.release()  # 解锁 计数-1 counter=0

6.6 threading.Condition
一个condition变量总是与某些类型的锁相联系，这个可以使用默认的情况或创建一个，当几个condition变量必须共享和同一个锁的时候，是很有用的。锁是conditon对象的一部分：没有必要分别跟踪。
condition变量服从上下文管理协议：with语句块封闭之前可以获取与锁的联系。 acquire() 和 release() 会调用与锁相关联的相应的方法。
其他和锁关联的方法必须被调用，wait()方法会释放锁，当另外一个线程使用 notify() or notify_all()唤醒它之前会一直阻塞。一旦被唤醒，wait()会重新获得锁并返回，Condition类实现了一个conditon变量。 这个conditiaon变量允许一个或多个线程等待，直到他们被另一个线程通知。 如果lock参数，被给定一个非空的值，，那么他必须是一个lock或者Rlock对象，它用来做底层锁。否则，会创建一个新的Rlock对象，用来做底层锁。
wait(timeout=None) ： 等待通知，或者等到设定的超时时间。当调用这wait()方法时，如果调用它的线程没有得到锁，那么会抛出一个RuntimeError 异常。 wati()释放锁以后，在被调用相同条件的另一个进程用notify() or notify_all() 叫醒之前 会一直阻塞。wait() 还可以指定一个超时时间。
如果有等待的线程，notify()方法会唤醒一个在等待conditon变量的线程。notify_all() 则会唤醒所有在等待conditon变量的线程。

注意： notify()和notify_all()不会释放锁，也就是说，线程被唤醒后不会立刻返回他们的wait() 调用。除非线程调用notify()和notify_all()之后放弃了锁的所有权。

在典型的设计风格里，利用condition变量用锁去通许访问一些共享状态，线程在获取到它想得到的状态前，会反复调用wait()。修改状态的线程在他们状态改变时调用 notify() or notify_all()，用这种方式，线程会尽可能的获取到想要的一个等待者状态。 例子： 生产者-消费者模型，

import threading
import time

def consumer(cond):
    with cond:
        print("consumer before wait")
        cond.wait()
        print("consumer after wait")

def producer(cond):
    with cond:
        print("producer before notifyAll")
        cond.notifyAll()
        print("producer after notifyAll")

condition = threading.Condition()
c1 = threading.Thread(name="c1", target=consumer, args=(condition,))
c2 = threading.Thread(name="c2", target=consumer, args=(condition,))

p = threading.Thread(name="p", target=producer, args=(condition,))

c1.start()
time.sleep(2)
c2.start()
time.sleep(2)
p.start()