多线程学习笔记

线程之间的依赖关系，线程锁

#coding=utf-8
"""
进程: 要以一个整体的形式暴露给操作系统管理，里面包含对各种资源的调用，内存的管理，网络接口的调用等。。。
对各种资源管理的集合 就可以成为  进程
线程: 是操作系统最小的调度单位， 是一串指令的集合
进程 要操作cpu , 必须要先创建一个线程  ，
所有在同一个进程里的线程是共享同一块内存空间的
进程与线程的区别？
线程共享内存空间，进程的内存是独立的
同一个进程的线程之间可以直接交流，两个进程想通信，必须通过一个中间代理来实现
创建新线程很简单， 创建新进程需要对其父进程进行一次克隆
一个线程可以控制和操作同一进程里的其他线程，但是进程只能操作子进程
"""
import threading
import time
# def run(n):
#     print 'it is ',n,threading.current_thread()
#     time.sleep(5)
#     print 'done'

# t1 = threading.Thread(target = run,args=('x1',))
# t2 = threading.Thread(target = run,args=('x1',))
# t1.start()
# t2.start()
# run('x1')
# run('x1')
class MyThread(threading.Thread):       #继承式调用
    def __init__(self,n):
        super(MyThread,self).__init__()
        self.n = n
    def run(self):
        print 'now run is',self.n,threading.current_thread()

# t1 = MyThread('x1')
# t2 = MyThread('x2')
# t1.start()
# t2.start()
# start_time = time.time()     #主线程不会等子线程执行完毕就会继续往下走，所以花费时间的值不是5S
# t_obj = []   #储存线程实例的列表
# for i in range(50):
#     t1 = threading.Thread(target=run, args=('x%s'%i,))
#     t1.setDaemon(True)  #当前线程设置为守护线程，主线程完成之后不会等待守护线程执行到什么进度直接退出。
#     t1.start()
#     t_obj.append(t1)
# print '__________',threading.active_count()
# # for i in t_obj:
# #     i.join()                        #等待所有线程结束之后再往下继续执行
#
# print 'cost time is ',time.time()-start_time,threading.current_thread(),threading.active_count()  #返回当前线程，返回活跃的线程个数
#加入 t1.join()就会等待t1执行完成后再往下走,循环的50个属于子线程，主线程不包含在内，所以当前执行的线程一共有51个
# num = 0
# lock = threading.Lock()                 #加入进程锁
# def run(n):
#     lock.acquire()             #获取锁
#     global num
#     num += 1
#     #time.sleep(1)             #加入sleep就会变成串行，等待时间释放锁
#     lock.release()             #释放锁
#
# t_obj = []
# for i in range(50):
#     t1 = threading.Thread(target=run, args=('x%s'%i,))
#     t1.start()
#     t_obj.append(t1)
# for i in t_obj:
#     i.join()
#
# print 'now num is ',num

#递归锁
import threading, time


def run1():
    print("grab the first part data")
    lock.acquire()
    global num
    num += 1
    lock.release()
    return num


def run2():
    print("grab the second part data")
    lock.acquire()
    global num2
    num2 += 1
    lock.release()
    return num2


def run3():
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res, res2)




# num, num2 = 0, 0
# lock = threading.RLock()
# for i in range(1):
#     t = threading.Thread(target=run3)
#     t.start()
#
# while threading.active_count() != 1:               #等待子进程结束的另一种方式
#     print(threading.active_count())
# else:
#     print('---- done---')
#     print(num, num2)