学习笔记15

线程可以对同一进程的线程进行相当程度的控制;                             
                     进程只能对子进程进行控制。

__author__ = "Narwhale"

import threading,time

event = threading.Event()

def light():
    event.set()
    count = 0
    while True:
        if count >5 and count < 10:
            event.clear()
            print('33[41;1m红灯亮了33[0m' )
        elif count > 10:
            event.set()
            count = 0
        else:
            print('33[42;1m绿灯亮了33[0m')
        time.sleep(1)
        count +=1


def car(n):
    while True:
        if event.isSet():
            print('33[34;1m%s车正在跑!33[0m'%n)
            time.sleep(1)
        else:
            print('车停下来了')
            event.wait()

light = threading.Thread(target=light,args=( ))
light.start()
car1 = threading.Thread(target=car,args=('Tesla',))
car1.start()

3.一条进程至少有一条线程

 

6.join的作用是 等待线程执行完毕

7.练习

线程共享内存空间,                                                     
                                         进程的内存是独立的

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

 

__author__ = "Narwhale"
import queue,time,threading
q = queue.Queue(10)

def producer(name):
    count = 0
    while True:
        print('%s生产了包子%s'%(name,count))
        q.put('包子%s'%count)
        count += 1
        time.sleep(1)

def consumer(name):
    while True:
        print('%s取走了%s,并且吃了它。。。。。'%(name,q.get()))
        time.sleep(1)


A1 = threading.Thread(target=producer,args=('A1',))
A1.start()

B1 = threading.Thread(target=consumer,args=('B1',))
B1.start()
B2 = threading.Thread(target=consumer,args=('B2',))
B2.start()

生产者消费者模型

2.线程与进程的区别

对主线程的更改(取消,优先级更改等)可能会影响进程其他线程的行为;       
    对父进程的更改不会影响子进程。

信号量

线程可以直接与其进程的其他线程通信;                                     
                           进程必须使用进程间通信与兄弟进程进行通信。

    互斥锁
同时只允许一个线程更改数据,而Semaphore是同时允许一定数量的线程更改数据
,比如厕所有3个坑,那最多只允许3个人上厕所,后面的人只能等里面有人出来了才能再进去。

__author__ = "Narwhale"

import threading,time

def run(n):
    semaphore.acquire()
    time.sleep(1)
    print('线程%s在跑!'%n)
    semaphore.release()

if __name__ == '__main__':
    semaphore = threading.BoundedSemaphore(5)      #最多5个线程同时跑
    for i in range(20):
        t = threading.Thread(target=run,args=(i,))
        t.start()

while threading.active_count() !=1:
    pass
else:
    print('所有线程跑完了!')

线程共享创建它的进程的地址空间;                                         
                              进程拥有自己的地址空间。

4.线程锁
   
每个线程在要修改公共数据时,为了避免自己在还没改完的时候别人也来修改此数据,可以给这个数据加一把锁,
这样其它线程想修改此数据时就必须等待你修改完毕并把锁释放掉后才能再访问此数据

 

5.Semaphore(信号量)

红绿灯

 

澳门新葡亰平台官网 ,新线程很容易创建;                                                       
                                          新流程需要重复父流程。

1.线程进程
进程:程序并不能单独运行,只有将程序装载到内存中,系统为它分配资源才能运行,而这种执行的程序就称之为进程,不具备执行感念,只是程序各种资源集合

 

线程可以直接访问其进程的数据段;                                         
                              进程拥有父进程的数据段的自己的副本。

发表评论

电子邮件地址不会被公开。 必填项已用*标注