谈谈对线程与进程的理解

概念：

线程

线程（threading)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

进程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

进程与线程区别

a.地址空间和其它资源：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。

b.通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。

c.调度和切换：线程上下文切换比进程上下文切换要快得多。

d.在多线程OS中，进程不是一个可执行的实体。

threading模块

直接调用

 1 import threading
 2 import time
 3
 4 def tell(num): #定义每个线程要运行的函数
 5
 6     print(num)
 7     time.sleep(3)
 8
 9 if __name__ == '__main__':
10     t1 = threading.Thread(target=tell,args=(1,)) #生成一个线程实例
11     t2 = threading.Thread(target=tell,args=(2,)) #生成另一个线程实例
12     t1.start() #启动线程
13     t2.start() #启动另一个线程
14     print(t1.getName()) #获取线程名
15     print(t2.getName())

View Code

继承调用

 1 __author__ = 'thinkpad'
 2 # !/usr/bin/env python
 3 #-*- coding:utf-8 -*-
 4
 5 import threading
 6 import time
 7
 8 class MyThread(threading.Thread):
 9
10     def __init__(self,num):
11         threading.Thread.__init__(self)
12         self.num = num
13     def run(self):#定义每个线程要运行的函数
14         print(self.num)
15         time.sleep(3)
16
17 if __name__ == '__main__':
18     t1 = MyThread(1)
19     t2 = MyThread(2)
20     t1.start()
21     t2.start()
22     print(t1.getName())
23     print(t2.getName())

View Code

互拆锁

 1 __author__ = 'thinkpad'
 2 # !/usr/bin/env python
 3 #-*- coding:utf-8 -*-
 4 import threading
 5 import time
 6
 7 def addNum():
 8     global num #在每个线程中都获取这个全局变量
 9     print('--get num:',num )
10     time.sleep(1)
11     lock.acquire() #修改数据前加锁
12     num  -=1 #对此公共变量进行-1操作
13     lock.release() #修改后释放
14 num = 100  #设定一个共享变量
15 thread_list = []
16
17 lock = threading.Lock() #生成全局锁
18 for i in range(100):
19     t = threading.Thread(target=addNum)
20     t.start()
21     thread_list.append(t)
22
23 for t in thread_list: #等待所有线程执行完毕
24     t.join()
25 print('final num:', num )

View Code

多进程Mutiprocessing

 1 from multiprocessing import Process
 2 import time
 3 def f(name):
 4     time.sleep(2)
 5     print('hello', name)
 6
 7 if __name__ == '__main__':
 8     for i in range(4):
 9         p = Process(target=f, args=('bob',))
10         p.start()
11         p.join()

View Code

 1 from multiprocessing import Process
 2 import os
 3
 4 def info(title):
 5     print(title)
 6     print('module name:', __name__)
 7     print('parent process:', os.getppid())
 8     print('process id:', os.getpid())
 9     print("\n\n")
10
11 def f(name):
12     info('\033[31;1mfunction f\033[0m')
13     print('hello', name)
14
15 if __name__ == '__main__':
16     info('\033[32;1mmain process line\033[0m')
17     p = Process(target=f, args=('bob',))
18     p.start()
19     p.join()

View Code

进程间通讯

queues

 1 from multiprocessing import Process, Queue
 2
 3 def f(q):
 4     q.put([42, None, 'hello'])
 5
 6 if __name__ == '__main__':
 7     q = Queue()
 8     p = Process(target=f, args=(q,))
 9     p.start()
10     print(q.get())    # prints "[42, None, 'hello']"
11     p.join()

View Code

Pipes

 1 from multiprocessing import Process, Pipe
 2
 3 def f(conn):
 4     conn.send([42, None, 'hello'])
 5     conn.close()
 6
 7 if __name__ == '__main__':
 8     parent_conn, child_conn = Pipe()
 9     p = Process(target=f, args=(child_conn,))
10     p.start()
11     print(parent_conn.recv())   # prints "[42, None, 'hello']"
12     p.join()

View Code

Mangager

 1 from multiprocessing import Process, Manager
 2
 3 def f(d, l):
 4     d[1] = '1'
 5     d[2] = '2'
 6     d[0.25] = None
 7     l.append(1)
 8     print(l)
 9
10 if __name__ == '__main__':
11     with Manager() as manager:
12         d = manager.dict()
13
14         l = manager.list(range(5))
15         p_list = []
16         for i in range(10):
17             p = Process(target=f, args=(d, l))
18             p.start()
19             p_list.append(p)
20         for res in p_list:
21             res.join()
22
23         print(d)
24         print(l)

View Code

进程同步

 1 from multiprocessing import Process, Lock
 2
 3 def f(l, i):
 4     l.acquire()
 5     try:
 6         print('hello world', i)
 7     finally:
 8         l.release()
 9
10 if __name__ == '__main__':
11     lock = Lock()
12
13     for num in range(10):
14         Process(target=f, args=(lock, num)).start()

View Code

进程池

 1 from  multiprocessing import Process,Pool
 2 import time
 3
 4 def Foo(i):
 5     time.sleep(2)
 6     return i+100
 7
 8 def Bar(arg):
 9     print('-->exec done:',arg)
10
11 pool = Pool(5)
12
13 for i in range(10):
14     pool.apply_async(func=Foo, args=(i,),callback=Bar)
15     #pool.apply(func=Foo, args=(i,))
16
17 print('end')
18 pool.close()
19 pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。

View Code

转载于:https://www.cnblogs.com/lizheng19822003/p/5295471.html

谈谈对线程与进程的理解相关推荐

python 线程、进程的理解
一.操作系统概念操作系统位于底层硬件与应用软件之间的一层.工作方式:向下管理硬件,向上提供接口. 操作系统进行进程切换:1.出现IO操作:2.固定时间. 固定时间很短,人感受不到.每一个应用层运行起 ...
并发与并行，线程与进程如何理解
线程，进程，线程安全的理解
1.谈谈对进程的理解? 答:首先进程是指在系统中正在运行的一个应用程序:程序一旦运行就是进程,或者更专业化来说:进程是指程序执行时的一个实例,即它是程序已经执行到课中程度的数据结构的汇集.从内核的观点 ...
iOS开发 - 线程与进程的认识与理解
进程: 进程是指在系统中正在运行的一个应用程序,比如同时打开微信和Xcode,系统会分别启动2个进程; 每个进程之间是独立的,每个进程均运行在其专用且受保护的内存空间内; 线程: 一个进程要想执行任务 ...
对线程与进程的区别以及对多线程并发的理解
一.线程与进程的区别先简单说说线程与进程的概念: (1)进程是指一个内存中运行的应用程序,比如在Windows系统中,一个运行的exe就是一个进程. (2)线程是指进程中的一个执行流程. 区别: 一 ...
线程与进程，你真得理解了吗
线程与进程,你真得理解了吗 1 进程与线程的关系和区别 2 并行与并发 3 线程共享了进程哪些资源相信大家面试时一定没少被一个问题刁难,那就是进程和线程的区别是什么?这个问题延申开来并不像表面那么简 ...
我所理解的线程和进程
我所理解的线程和进程(一) 0x00 没什么卵用的前言最近刚巧和朋友讨论起进程和线程的概念,于是突发奇想写了这篇博客,希望不依托于具体的编程语言和平台简述进程和线程的概念,所以本篇博客不讨论实现细节 ...
如何理解线程与进程（含有通俗解释）
1.线程与进程: 线程和进程应该是学计算机的朋友听的比较多的词汇了,其实就算不学习计算机,懂电脑的朋友也可能有点印象,因为我们的CPU经常说到8和16线程什么的,仿佛线程越多代表CPU性能越强悍,那么 ...
java伪唤醒,谈谈JDK线程的伪唤醒
在JDK的官方的wait()方法的注释中明确表示线程可能被"虚假唤醒",JDK也明确推荐使用while来判断状态信息.那么这种情况的发生的可能性有多大呢? 使用生产者消费者模型来说 ...

谈谈对线程与进程的理解

谈谈对线程与进程的理解相关推荐

最新文章

热门文章