python笔记之进程线程

在学习python对应线程、进程模块之前先了解一下线程、进程概念。

进程：就是一块包含了某些资源的内存区域，操作系统利用进程把他的工作划分为一些功能单元。进程中包含一个或多个线程，用于自己私有的虚拟地址空间。该空间仅能被他所包含的线程访问。当操作系统创建一个主线程后，该进程会自动申请一个名为主线程或首要线程的线程。简单来说，进程就是指正在运行的程序。也就是说，当一个程序进入内存运行，就变成了一个进程。
线程：是一个进程中的执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个程序也可以称为多线程程序。线程在切换时负荷小，所以线程也被称为轻负荷进程。
　　总之：一个程序运行后，至少有一个进程，一个进程中包含一个或者多个线程。

多线程就是一个程序中有多个线程在同时执行。

线程和进程的区别：

1. 　　一个进程至少有一个线程，线程的划分尺度小于进程。
2. 　　进程应有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。　线程在执行过程中，每个独立的线程有一个程序运行的入口，顺序执行序列，程序运行的出口，但是线程不能独立运行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

线程使用的场合
线程通常用于在一个程序中需要同时完成多个任务的情况，我们可以将每个任务定义为一个线程，使得他们一同工作。

并发原理
多个线程或进程“同时”运行只是我们感官上的一种表现，事实上进程和线程是并发运行的。OS的线程调度机制将时间划分为很多时间片段（时间片），尽可能的均匀分配给正在运行的程序。获取到时间片的线程或进程才会被执行，其他的则处于等待状态，而CPU则在这些进程和线程上来回切换运行。
原文链接：https://blog.csdn.net/he_zhen_/article/details/87456727

python中使用threading模块进行线程处理

#!/usr/bin/python3

import threading
import time

exitFlag = 0
class myThread(threading.Thread):
   def __init__(self,threadID,name,delay):
      threading.Thread.__init__(self)
      self.name = name
      self.delay = delay

   def run(self):
      print("开启线程:"+self.name)
      print_time(self.name,self.delay,5)
      print("退出线程："+self.name)



def print_time(threadName,delay,counter):
   while counter:
      if exitFlag:
         threadName.exit()
      time.sleep(delay)
      print("%s:%s" %(threadName,time.ctime(time.time())))
      counter -= 1

#创建新线程
thread1 = myThread(1,"Thread-1",1)
thread2 = myThread(2,"Thread-2",2)

#开启新线程
thread1.start() #启动线程活动
thread2.start()
thread1.join()  #等待至线程中止
thread2.join()
print("退出主线程")

线程同步

如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。如下：

多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。

#!/usr/bin/python3

import threading
import time

exitFlag = 0
class myThread(threading.Thread):
   def __init__(self,threadID,name,delay):
      threading.Thread.__init__(self)
      self.name = name
      self.delay = delay

   def run(self):
      print("开启线程:"+self.name)
      threadLock.acquire()
      print_time(self.name,self.delay,5)
      threadLock.release()
      print("退出线程："+self.name)



def print_time(threadName,delay,counter):
   while counter:
      if exitFlag:
         threadName.exit()
      time.sleep(delay)
      print("%s:%s" %(threadName,time.ctime(time.time())))
      counter -= 1

threadLock = threading.Lock()
threads = []

#创建新线程
thread1 = myThread(1,"Thread-1",1)
thread2 = myThread(2,"Thread-2",2)

#开启新线程
thread1.start() #启动线程活动
thread2.start()

#添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

for t in threads:
   t.join()    #等待至线程中止
print("退出主线程")

线程优先级队列（ Queue）

Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。

这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。

Queue 模块中的常用方法: 

• Queue.qsize() 返回队列的大小
• Queue.empty() 如果队列为空，返回True,反之False
• Queue.full() 如果队列满了，返回True,反之False
• Queue.full 与 maxsize 大小对应
• Queue.get([block[, timeout]])获取队列，timeout等待时间
• Queue.get_nowait() 相当Queue.get(False)
• Queue.put(item) 写入队列，timeout等待时间
• Queue.put_nowait(item) 相当Queue.put(item, False)
• Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
• Queue.join() 实际上意味着等到队列为空，再执行别的操作

import queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q
    def run(self):
        print ("开启线程：" + self.name)
        process_data(self.name, self.q)
        print ("退出线程：" + self.name)

def process_data(threadName, q):
    while not exitFlag:
        queueLock.acquire()
        if not q.empty():
            data = q.get()
            queueLock.release()
            print ("%s processing %s" % (threadName, data))
        else:
            queueLock.release()
        time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

# 创建新线程
for tName in threadList:
    thread = myThread(threadID, tName, workQueue)
    thread.start()
    threads.append(thread)
    threadID += 1

# 填充队列
queueLock.acquire()
for word in nameList:
    workQueue.put(word)
queueLock.release()

# 等待队列清空
while not workQueue.empty():
    pass

# 通知线程是时候退出
exitFlag = 1

# 等待所有线程完成
for t in threads:
    t.join()
print ("退出主线程")

python中进程可以使用process模块

#!/usr/bin/env python
#-*-coding:utf-8-*-

from multiprocessing import  Process
import os
import time as t

def f():
    t.sleep(2)
    print("这是进程")

if __name__ == '__main__':
    p=Process(target=f)
    p.start()
    print('父进程PID：{0}'.format(os.getppid()))
    print('子进程PID：{0}'.format(os.getpid()))