07.操作系统进程同步

1.进程共享计算机资源(进程是独立运行的)(共享物理内存可以让进程同步)
(传递数据最快的方式)(带来不同步的问题)
2.使用共享内存同步的步骤

   1.申请共享内存
   2.连接到进程空间
   3.使用共享内存
   4.脱离进程空间&删除

3.unix域套接字(通过socket)(也是进程同步)(提供了单机简单可靠的进程通信同步服务,只能单机使用)

        服务器	               客户端
  1.创建套接字                   1.创建套接字
  2.绑定套接字                   2.连接套接字
  3.监听套接字       <----       3.发送信息
  4.接收和处理信息

4.异步任务的线程池(java ThreadPoolExecutor)
普通任务:用户提交任务 无需任务结果–>入队后在线程池执行
异步任务: 需要结果–>线程池返回结果
5.线程安全的队列
多个线程同时访问队列 —>互斥锁
队列元素为空,线程获取元素—>条件变量
6.python语法 没有{} 用:代表开始 没有定义变量 没有分号

  #传入参数都是对象,对于我来说好别扭
   #pass代表有{}占领着
   #设置字符集
   #还可以设置默认值在函数内
   # -*- encoding=utf-8 -*-#
   #模块化设计 import
   import threading
   class TreadSafeQueue(object):
        def __init__(self,max_size=0):
              self.queue=[]
              self.max_size=max_size
              self.lock=threading.Lock()    
              self.condition=threading.Condition()	
        #和yaml一样有空格的严格的要求 
        #return 直接返回不用定义
        #注释和linux一样
         
        #当前对列的长度
        def size(self):
              self.lock.acquire()
               size=len(self.queue)
               self.lock.release() 
               return size          
               pass 
        #and代表 &&  or代表 ||
        #往对列里面放入元素
        def put(self,item):
               if self.max.size ! =0 and self.size()> self.max_size:
               return ThreadSafeQueueException();
               self .lock.acquire()  #加锁
               self.queue.append(item)
               self.lock.release()   #解锁
               self .condition.acquire()  #多了条件变量的加锁
               self.queue.notify()#通知其他进程继续执行
               self.condition.release()   #多了条件变量的解锁
        #批量往队列放入元素
        # not 相当于 !
        #list相当于py的关键字,是List对象
        #for循环用先进的 for in,java也有
        def batch_put(self,item_list):
               if not isinstance(item_list,list): 
               for item in item_list:
                      self.put(item)
        #None相当于字符串,是特殊的定义不相当于null
        #直接写block也没有毛病
        #timeout=timeout说明调用函数的时候是键=值
        #从队列取出元素的方法
        def pop(self,block=False,timeout=None):
              
              if self.size()==0:
                  #需要阻塞等待
	          if block:
                         if timeout == None:
                            timeout = 0
                            self.condition.acquire()
                            self.condition.wait(timeout=timeout)
                            self.condition.release()
	         else:
                             return None
                     if self.size()--0:
                          return None
                     self.lock.acquire()
                     item=self.queue.pop()
                     self.lock.release()
                     return item
                   pass
              pass
       def get(self,index):
          pass

      #测试
      #if也可以不在函数里面
    if __name== '__main__':
       #self就是传入的object对象,还可以有__init__默认函数
       #自动传入数据到对象
       queue=ThreadSafeQueue(max_size=100)
        
        def producer():
              while True:
                       queue.put(1)
                       time.sleep(3)
        def consumer():
               while True:
                      item= queue.pop(block=True, timeout=2)
                     #类似js的输出
                      print('get item from queue ',item)
                      time.sleep(1)
        thread1= threading.Thread(target=producer)
        thread2= threading.Thread(target=consumer)
        thread1.start() #启动线程
        thread2.start()  
        thread1.join() #等待结束,结束线程
        thread2.join()  
         
       
         

                
    #类不用new 直接向方法一样调用,测试也可以不用传
   class ThreadSafeQueueException(Exception):
     pass