import threading
import time

def countNum(n): # 定义某个线程要运行的函数

    print("running on number:%s" %n)

    time.sleep(3)

if __name__ == ‘__main__‘:

    t1 = threading.Thread(target=countNum,args=(23,)) #生成一个线程实例
    t2 = threading.Thread(target=countNum,args=(34,))

    t1.start() #启动线程
    t2.start()

    print("ending!")

#继承Thread式创建

import threading
import time

class MyThread(threading.Thread):

    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num=num

    def run(self):
        print("running on number:%s" %self.num)
        time.sleep(3)

t1=MyThread(56)
t2=MyThread(78)

t1.start()
t2.start()
print("ending")

# join()：在子线程完成运行之前，这个子线程的父线程将一直被阻塞。

# setDaemon(True)：
        ‘‘‘
         将线程声明为守护线程，必须在start() 方法调用之前设置，如果不设置为守护线程程序会被无限挂起。

         当我们在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程 就分兵两路，分别运行，那么当主线程完成

         想退出时，会检验子线程是否完成。如果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是只要主线程

         完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以 用setDaemon方法啦‘‘‘

import threading
from time import ctime,sleep
import time

def Music(name):

        print ("Begin listening to {name}. {time}".format(name=name,time=ctime()))
        sleep(3)
        print("end listening {time}".format(time=ctime()))

def Blog(title):

        print ("Begin recording the {title}. {time}".format(title=title,time=ctime()))
        sleep(5)
        print(‘end recording {time}‘.format(time=ctime()))


threads = []


t1 = threading.Thread(target=Music,args=(‘FILL ME‘,))
t2 = threading.Thread(target=Blog,args=(‘‘,))

threads.append(t1)
threads.append(t2)

if __name__ == ‘__main__‘:

    for t in threads:
        t.start()

    print ("all over %s" %ctime())
‘‘‘
运行结果
Begin listening to FILL ME. Tue Jul 18 16:15:06 2017
Begin recording the . Tue Jul 18 16:15:06 2017
all over Tue Jul 18 16:15:06 2017
end listening Tue Jul 18 16:15:09 2017
end recording Tue Jul 18 16:15:11 2017



前三行瞬间执行完毕，后两行等待3秒和5秒执行

‘‘‘

if __name__ == ‘__main__‘:

    for t in threads:
        t.setDaemon(True) #注意:一定在start之前设置
        t.start()

    print("all over %s" % ctime())
‘‘‘
运行结果：
Begin listening to FILL ME. Tue Jul 18 16:31:23 2017
Begin recording the . Tue Jul 18 16:31:23 2017
all over Tue Jul 18 16:31:23 201

每个线程都是守护线程，跟随主线程一块挂掉
‘‘‘

if __name__ == ‘__main__‘:

    # t2.setDaemon(True)

    for t in threads:
        # t.setDaemon(True) #注意:一定在start之前设置
        t.start()

    t1.join()

    print("all over %s" % ctime())
‘‘‘
运行结果：
Begin listening to FILL ME. Tue Jul 18 16:34:41 2017
Begin recording the . Tue Jul 18 16:34:41 2017
end listening Tue Jul 18 16:34:44 2017
all over Tue Jul 18 16:34:44 2017
end recording Tue Jul 18 16:34:46 2017

前两行瞬间执行完成后等待，第二三行一起执行，最后一行最后出现。
在t1.join()处阻塞，t1线程运行完毕，主线程才继续执行。
‘‘‘

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法：
  # threading.currentThread(): 返回当前的线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

‘‘‘
定义：
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

翻译：
在CPython中，全局解释器锁是一个互斥锁，它可以防止多个本机线程同时执行Python的编译器。这个锁是必需的，主要是因为CPython的内存管理不是线程安全的。(然而，由于GIL的存在，其他的特性已经发展到依赖于它的保证。)
‘‘‘

当然multiprocessing也不是万能良药。它的引入会增加程序实现时线程间数据通讯和同步的困难。就拿计数器来举例子，如果我们要多个线程累加同一个变量，对于thread来说，申明一个global变量，用thread.Lock的context包裹住三行就搞定了。而multiprocessing由于进程之间无法看到对方的数据，只能通过在主线程申明一个Queue，put再get或者用share memory的方法。这个额外的实现成本使得本来就非常痛苦的多线程程序编码，变得更加痛苦了。

总结：因为GIL的存在，只有IO Bound场景下得多线程会得到较好的性能 - 如果对并行计算性能较高的程序可以考虑把核心部分换成C模块，或者索性用其他语言实现 - GIL在较长一段时间内将会继续存在，但是会不断对其进行改进。

所以对于GIL，既然不能反抗，那就学会去享受它吧！

import time
import threading
def addNum():
    global num #在每个线程中都获取这个全局变量
    #num-=1

    temp=num
    time.sleep(0.1)
    num =temp-1  # 对此公共变量进行-1操作

num = 100  #设定一个共享变量

thread_list = []

s=time.time()
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕
    t.join()

print(‘Result: ‘, num ,‘cost time: ‘ ,time.time()-s)
#运行结果
#Result:  99 cost time:  0.11100625991821289

import threading

R=threading.Lock()

R.acquire()
‘‘‘
对公共数据的操作
‘‘‘
R.release()

import time
import threading
def addNum():
    global num #在每个线程中都获取这个全局变量
    #num-=1
    
    R.acquire()    #保护数据，串行执行
    temp=num
    time.sleep(0.1)
    num =temp-1  # 对此公共变量进行-1操作
    R.release()

num = 100  #设定一个共享变量
thread_list = []

R=threading.Lock()    #实例化锁对象

s=time.time()
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕
    t.join()

print(‘Result: ‘, num ,‘cost time: ‘ ,time.time()-s)
#运行结果
#Result:  0 cost time:  10.023573398590088    

import threading,time

LockA=threading.Lock()      #定义锁A
LockB=threading.Lock()      #定义锁B

class MyThread(threading.Thread):

    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.foo()
        self.bar()

    def foo(self):
        LockA.acquire()     #加A锁
        print(‘I am foo %s get LOCKA-------%s‘%(self.name,time.ctime()))

        LockB.acquire()     #加B锁
        print(‘I am foo %s get LOCKB-------%s‘ % (self.name, time.ctime()))
        LockB.release()     #解B锁

        LockA.release()     #解A锁，A锁被线程2拿到

    def bar(self):
        LockB.acquire()     #加B锁
        print(‘I am bar %s get LOCKB-------%s‘ % (self.name, time.ctime()))

        LockA.acquire()     #需要加A锁，但A锁被线程2占用，线程2需要加B锁，相互拿不到锁，造成死锁
        print(‘I am bar %s get LOCKA-------%s‘ % (self.name, time.ctime()))
        LockA.release()

        LockB.release()for i in range(10):
    t=MyThread()
    t.start()
‘‘‘
运行结果：
I am foo Thread-1 get LOCKA-------Tue Jul 18 18:22:26 2017
I am foo Thread-1 get LOCKB-------Tue Jul 18 18:22:26 2017
I am bar Thread-1 get LOCKB-------Tue Jul 18 18:22:26 2017
I am foo Thread-2 get LOCKA-------Tue Jul 18 18:22:26 2017
‘‘‘

import threading,time

Rlock=threading.RLock()　　#定义递归锁

class MyThread(threading.Thread):

    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.foo()
        self.bar()

    def foo(self):
        Rlock.acquire()     #递归锁counter+1
        print(‘I am foo %s get LOCKA-------%s‘%(self.name,time.ctime()))

        Rlock.acquire()     #递归锁counter+1
        print(‘I am foo %s get LOCKB-------%s‘ % (self.name, time.ctime()))
        Rlock.release()     #递归锁counter-1

        Rlock.release()     #递归锁counter-1　　递归锁counter为零，可被其他线程获取

    def bar(self):
        Rlock.acquire()     #递归锁counter+1
        print(‘I am bar %s get LOCKB-------%s‘ % (self.name, time.ctime()))

        Rlock.acquire()     #递归锁counter+1
        print(‘I am bar %s get LOCKA-------%s‘ % (self.name, time.ctime()))
        Rlock.release()　　　#递归锁counter-1

        Rlock.release()　　　#递归锁counter-1

for i in range(10):
    t=MyThread()
    t.start()

import threading
import time

semaphore = threading.Semaphore(5)

def func():
    if semaphore.acquire():
        print (threading.currentThread().getName() + ‘ get semaphore‘)
        time.sleep(2)
        semaphore.release()

for i in range(20):
  t1 = threading.Thread(target=func)
  t1.start()

‘‘‘
运行结果：
Thread-1 get semaphore
Thread-2 get semaphore
Thread-3 get semaphore
Thread-4 get semaphore
Thread-5 get semaphore
Thread-6 get semaphore
Thread-8 get semaphore
Thread-7 get semaphore
Thread-10 get semaphore
Thread-9 get semaphore
Thread-12 get semaphore
Thread-11 get semaphore
Thread-13 get semaphore
Thread-14 get semaphore
Thread-15 get semaphore
Thread-16 get semaphore
Thread-17 get semaphore
Thread-18 get semaphore
Thread-19 get semaphore
Thread-20 get semaphore

每5个一起打印
‘‘‘