同步，互斥锁解决多线程资源共享问题

@同步，互斥锁解决多线程资源共享问题

  1 import threading
  2 import time
  3 
  4 g_num=0
  5 def test1(temp):
  6 
  7     global g_num
  8     mutex.acquire()
  9     for i in range(temp):
 10         g_num+=1
 11     mutex.release()
 12     print(g_num)
 13 
 14          
 15 def test2(temp):
 16     global g_num
 17     mutex.acquire()
 18     for i in range(temp):
 19         g_num+=1
 20     mutex.release()
 21     print(g_num)
 22 
 23 mutex=threading.Lock()
 24 def main():
 25     t1=threading.Thread(target=test1,args=(1000000,))
 26     t2=threading.Thread(target=test2,args=(1000000,))
 27 
 28     t1.start()
 29     t2.start()
 30 
 31     time.sleep(5)
 32 
 33 
 34 if __name__=="__main__":
 35     main()
 
  **代码换一下位置（互斥锁的地方）：**
  5 def test1(temp):
  6 
  7     global g_num
  8     for i in range(temp):
  9         mutex.acquire()
 10         g_num+=1
 11         mutex.release()
 12     print(g_num)
 13 
 14 
 15 def test2(temp):
 16     global g_num
 17     for i in range(temp):
 18         mutex.acquire()
 19         g_num+=1
 20         mutex.release()
 21     print(g_num)

 结果如下：
  1954598
  2000000

@进程和线程

  1 import threading
  2 import time
  3 import multiprocessing
  4 def test1():
  5     for i in range(5):
  6         print("1--------")
  7         time.sleep(1)
  8 
  9 def test2():
 10     while True:
 11         print("2--------")
 12         time.sleep(1)
 13 
 14 def main():
 15     t1=multiprocessing.Process(target=test1)
 16     t2=multiprocessing.Process(target=test2)
 17     t1.start()
 18     t2.start()
 19 
 20 if __name__=="__main__":
 21     main()

进程所占内存多，写时拷贝（主进程和子进程），线程相对于进程所占内存少

进程和线程的区别：
进程是资源分配的基本单位，线程是操作系统调度的基本单位，线程不能独立运行，必须依托在进程中，好比工厂流水线，进程是工厂的一条流水线，线程是流水线的工人。
进程之间相互独立，线程共享全局变量。