专栏首页IT 茂茂进程、线程、协程

进程、线程、协程

先来欣赏一段有趣的漫画对话哦

————— 第二天 —————

——————————————————


什么事进程和线程

有一定基础的小伙伴们肯定都知道进程和线程。

进程是什么呢?

直白地讲,进程就是应用程序的启动实例。比如我们运行一个游戏,打开一个软件,就是开启了一个进程。

进程拥有代码和打开的文件资源、数据资源、独立的内存空间。

线程又是什么呢?

线程从属于进程,是程序的实际执行者。一个进程至少包含一个主线程,也可以有更多的子线程。

线程拥有自己的栈空间。

有了进程为什么还需要线程

因为进程不能同一时间只能做一个事情

什么是线程

线程是操作系统调度的最小单位

线程是进程正真的执行者,是一些指令的集合(进程资源的拥有者)

同一个进程下的读多个线程共享内存空间,数据直接访问(数据共享)

为了保证数据安全,必须使用线程锁

GIL全局解释器锁

在python全局解释器下,保证同一时间只有一个线程运行

防止多个线程都修改数据

线程锁(互斥锁)

GIL锁只能保证同一时间只能有一个线程对某个资源操作,但当上一个线程还未执行完毕时可能就会释放GIL,其他线程就可以操作了

线程锁本质把线程中的数据加了一把互斥锁

mysql中共享锁 & 互斥锁

mysql共享锁:共享锁,所有线程都能读,而不能写

mysql排它锁:排它,任何线程读取这个这个数据的权利都没有

加上线程锁之后所有其他线程,读都不能读这个数据

有了GIL全局解释器锁为什么还需要线程锁

因为cpu是分时使用的

死锁定义

两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去

进程和线程的痛点

线程之间是如何进行协作的呢?

最经典的例子就是生产者/消费者模式

若干个生产者线程向队列中写入数据,若干个消费者线程从队列中消费数据。

应用程序像工厂,进程像车间,线程像工人

一个进程中的线程可以在不同cpu上执行,一个线程不能同时在两个cpu上执行

python中有一个全局解释器锁(GIL global interpreter lock),他就像一把锁所在进程上,保证同一时刻,一个进程中无论有多少线程,只能保证有一个线程出来

随着cpu核数的增加,python中可以创建多个进程,一个进程中有一个全局解释器,这样一个cpu跑一个进程,一个进程同一时刻只能出一个线程,达到并行的目的

线程和进程的区别 :

线程是可以共享内存的,而进程不可以共享内存,一个进程就像一个应用程序,例如qq和淘宝,这属于两个进程,在QQ中发信息肯定不会发到淘宝中,但是在qq中存在很多的线程,他们可以共享内存,他们都属于一个进程,

假如eclipse在运行时占中400M的内存空间,那么这个进程下的线程的共享空间为这个主进程所占用的内存空间,就是eclipse的线程的内存共享就为400M

线程没有办法单独执行,线程必须在进程中

多进程之间的通信:

多进程之间无法直接通信,它必须借助一个第三方的桥梁

1 队列

from multiprocessing import Process, Queue 
def f(q,n): 
    q.put([ n, 'hello']) 
if __name__ == '__main__':
    q = Queue()

for i in range(5): 
        p = Process(target=f, args=(q,i)) 
        p.start() 
        print q.get() 

线程的安全问题,假如现在有十个线程,同时修改一个变量,让这个变量+1,那么会出现一个问题,假如A线程正在修改变量,现在变量为m=2,A线程操作m,目的是让A+1,然而A修改到一半的时候,线程B又进来了,线程B此时取的m的值也是2,A修改完了m=3,B修改完了m还是等于3 ,非常不安全

解决办法,就是加一把锁,形象的例子:

假如现在有10个人要上厕所,钥匙在我手里,这个时候A进来,他把门关上了,别人就进不去,只有等A完事后其他人才能进来,这个门就是控制线程的那把锁

代码实现就通过一个lock来实现,lock 只允许一个线程访问

lock=threading.Lock()

lock.acquire()

lock.release()

代码如下

val=0    #全局变量

def run(self,):
    #lock.acquire()
    time.sleep(1)
    global val 
    lock.acquire()
    val+=1
    print '%s' %val
    lock.release()        //这个地方执行完了必须relese,让后面的线程继续执行,否则后面无法执行
lock=threading.Lock()
for i in range(100):
    t=threading.Thread(target=run,args=(i,))
    t.start()

假如一个厕所门里有两个坑,允许两个人同时上厕所,即允许两个线程同时修改变量,那么用samp

samp = threading.BoundedSemaphore(3)

samp.acquire()

samp.release()

当参数为1时,实际上就等于lock

val=0    #全局变量

def run(self,):
    #lock.acquire()
    time.sleep(1)
    global val 
    samp.acquire()
    val+=1
    print '%s' %val
    samp.release()
lock=threading.Lock()
samp = threading.BoundedSemaphore(3)
for i in range(100):
    t=threading.Thread(target=run,args=(i,))
    t.start()

全局变量和局部变量

全局变量是在方法之外定义的变量,方法内部不能修改全局变量

例如 val=0 #全局变量

def run(self,n)

val+=1

程序会报错,方法内不能直接就该全局变量

在假如 val=0 #全局变量

def run(self,n)

val=1

print val

输出结果会是1,这是为什么呢,应为此时函数内部的val与全局变量val并不是一个,函数内部的 val是局部变量,函数外部的val为全局变量

假如 执行c=run(‘haha’)

print val

会输出 0

1

假如要在函数内重新定义局部变量

必须在函数中重新声明全局变量

val=0   #全局变量

    def run(self,n)

       global val

        val=1

       print val 

join() 执行到join时,例如执行到join(3)然后就在这个地方等待三秒,

from threading import Thread
import time
class MyThread(Thread):
    def run(self):
        time .sleep(5)
        print '我是线程'
def bar():
    print 'bar'
t1=MyThread(target=bar )
t1.start()
t1.join(3)
print ‘over'

采用面向类的生产者消费者模型

#_*_ coding:utf-8 _*_

from threading import Thread 
from Queue import Queue
import time
class Producer(Thread):
    def __init__(self,name,queue):
        self.__name=name
        self.__queue=queue
        super(Producer,self).__init__()                 #重写了父类的方法
    def run(self):
        while True:
            if self.__queue.full():
                time.sleep(1)
            else :
                self.__queue.put('baozi')
                time.sleep(1)
                print '%s生产了一个包子'%(self.__name)

class consumer(Thread):
    def __init__(self,name,queue):
        self.__name=name
        self.__queue=queue
        super(consumer,self).__init__()
    def run(self):
        while True:
            if self.__queue.empty():
                time.sleep(1)
            else :
                self.__queue.get()
                time.sleep(1)
                print '%s 消费一个包子'%(self.__name,)

que =Queue(maxsize=100)
baozi_make1=Producer('mahzongyi',que)
baozi_make1.start()
baozi_make2=Producer('mahzongyi1',que)
baozi_make2.start()
baozi_make3=Producer('mahzongyi2',que)
baozi_make3.start()
for item in range(20):
    name = 'lazup%d'%(item)
    temp=consumer(name,que)
    temp.start()

上面的代码正确地实现了生产者/消费者模式,但是却并不是一个高性能的实现。为什么性能不高呢?原因如下:

1.涉及到同步锁。

2.涉及到线程阻塞状态和可运行状态之间的切换。

3.涉及到线程上下文的切换。

以上涉及到的任何一点,都是非常耗费性能的操作。


什么事协程

协程,英文Coroutines,是一种比线程更加轻量级的存在。正如一个进程可以拥有多个线程一样,一个线程也可以拥有多个协程。

协程微线程,纤程,本质是一个单线程

协程能在单线程处理高并发

线程遇到I/O操作会等待、阻塞,协程遇到I/O会自动切换(剩下的只有CPU操作)

线程的状态保存在CPU的寄存器和栈里而协程拥有自己的空间,所以无需上下文切换的开销,所以快、

为甚么协程能够遇到I/O自动切换

协程有一个gevent模块(封装了greenlet模块),遇到I/O自动切换

协程缺点

无法利用多核资源:协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上

线程阻塞(Blocking)操作(如IO时)会阻塞掉整个程序

最重要的是,协程不是被操作系统内核所管理,而完全是由程序所控制(也就是在用户态执行)。

这样带来的好处就是性能得到了很大的提升,不会像线程切换那样消耗资源。

既然协程这么好,它到底是怎么来使用的呢?

我们来看一看python当中对协程的实现案例,同样以生产者消费者模式为例:

这段代码十分简单,即使没用过python的小伙伴应该也能基本看懂。

代码中创建了一个叫做consumer的协程,并且在主线程中生产数据,协程中消费数据。

其中 yield 是python当中的语法。当协程执行到yield关键字时,会暂停在那一行,等到主线程调用send方法发送了数据,协程才会接到数据继续执行。

但是,yield让协程暂停,和线程的阻塞是有本质区别的。协程的暂停完全由程序控制,线程的阻塞状态是由操作系统内核来进行切换。

因此,协程的开销远远小于线程的开销。

协程的应用

有哪些编程语言应用到了协程呢?我们举几个栗子:

Lua语言

Lua从5.0版本开始使用协程,通过扩展库coroutine来实现。

Python语言

正如刚才所写的代码示例,python可以通过 yield/send 的方式实现协程。在python 3.5以后,async/await 成为了更好的替代方案。

Go语言

Go语言对协程的实现非常强大而简洁,可以轻松创建成百上千个协程并发执行。

Java语言

如上文所说,Java语言并没有对协程的原生支持,但是某些开源框架模拟出了协程的功能,有兴趣的小伙伴可以看一看Kilim框架的源码:

https://github.com/kilim/kilim

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Python 三程三器的那些事

        1.定义:把一个函数名当做实参传给另一个函数     2.返回值中包含函数名     3.下面使用高阶函数虽然可以实现装饰器的一些功能,但是违反了装饰器...

    IT茂茂
  • Redis 【常识与进阶】

    Redis 是完全开源免费的,遵守BSD协议,是一个高性能的key-value数据库。

    IT茂茂
  • Python 【基础面试题】

    面试题仅做学习参考,学习者阅后也要用心钻研其中的原理,重要知识需要系统学习、透彻学习,形成自己的知识链。以下五点建议希望对您有帮助,早日拿到一份心仪的offer...

    IT茂茂
  • Linux下多线程的实现(基于pthread库)

    Linux内核在2.2版本中引入了类似线程的机制。Linux提供的vfork函数可以创建线程,此外Linux还提供了clone来创建一个线程,通过共享原来调用进...

    zy010101
  • C# 温故而知新: 线程篇(三)下

    结果计时器会一直滚动,因为a对象被锁住,除非完成Thread.Sleep(3000000)后才能进入到a共享区 ? 由于以上的问题,微软还是建议我们使用一个私有...

    逸鹏
  • 记一次Date引起的线上BUG处理

    在Java8以前,每每操控时间,我们经常使用的类库就是Date,并且会通过SimpleDateFormat类对时间进行格式化。你可知道?Date类是一个可变类,...

    程序员小明
  • java.util.concurrent 在shorturl项目中的应用

    问题:微博短链项目应用到哪些concurrent包中的类,类的用途是什么?场景是怎样?效果? java.util.concurrent.atomic.Atomi...

    财主刀刀
  • java多线程中的死锁、活锁、饥饿、无锁都是什么鬼?

    死锁、活锁、饥饿是关于多线程是否活跃出现的运行阻塞障碍问题,如果线程出现了这三种情况,即线程不再活跃,不能再正常地执行下去了。 死锁 死锁是多线程中最差的一种情...

    Java技术栈
  • python多线程开发

           通过threading.Thread创建一个线程对象,target是目标函数,name可以指定自己喜欢的名字,线程的启动需要借助start方法。线...

    py3study
  • 我画了25张图展示线程池工作原理和实现原理,原创干货,建议先收藏再阅读

    有朋友留言提到文中的场景是IO密集型操作,不是CPU密集操作,不需要使用线程池,我猜这位朋友可能想表达的是IO密集且阻塞时间久的不要使用线程池方案解决。IO密集...

    JavaQ

扫码关注云+社区

领取腾讯云代金券