一、程序與執行緒

       1. 一個程式至少有一個程序，一個程序至少有一個執行緒

       2. 執行緒的劃分尺度小於程序，使得多執行緒程式的併發性高

       3. 程序在執行過程中擁有獨立的記憶體單元，而多個執行緒共享記憶體，從而極大地提高了程式的執行效率

      4. 每個獨立的執行緒有一個程式執行的入口、順序執行序列和程式的出口。但是執行緒不能夠獨立執行，必須依存在應用程式中，由應用程式提供多個執行緒執行控制

      5. 多執行緒的意義在於一個應用程式中，有多個執行部分可以同時執行。但作業系統並沒有將多個執行緒看做多個獨立的應用，來實現程序的排程和管理以及資源分配

       當介面有大量的任務需要更新的時候  需要放入分執行緒

import threading
# 獲取當前執行緒的名稱 main主要的
print('當前執行緒為',threading.current_thread().name)
def myThread():
    print('位置1',threading.current_thread().name)
    print('位置2', threading.current_thread().name)
    print('位置3', threading.current_thread().name)
  
myThread()
class People(object):
    def thread_test(self):
        print('物件方法',threading.current_thread().name)
p = People()
p.thread_test()
# threading.Thread開闢一個新的執行緒  target目標 name分執行緒名稱
sub_thread = threading.Thread(target=myThread,name='newThread')

# 開始執行跟執行緒
sub_thread.start()

# 確保任務執行的順序 自己的執行緒先完成之後再執行其他執行緒
sub_thread.join()

# 當程式執行時，會先在主執行緒中執行（因為在程式剛開始的時候只有主執行緒，沒有分執行緒）
# 然後會根據情況進入到分執行緒，主執行緒和分執行緒的任務是交叉進行的，（因為兩個執行緒兩條路）
# 自己執行緒的執行情況不會影響對方執行緒
# 所以感覺是交叉的 分執行緒結束以後，會迴歸到主執行緒
print('outside1',threading.current_thread().name)
print('outside2',threading.current_thread().name)
print('outside3',threading.current_thread().name)
 

       執行緒鎖：當一個數據有多個執行緒都可以對其修改的時候，任何一個執行緒的改變都會被其他執行緒造成影響；如果某一個執行緒在使用完之前，其他執行緒不能對其修改，就需要對這個執行緒增加一個執行緒鎖。

count = 0
def get_money(money):
    global count
    count += money
    count += money
    count -= money
# 建立一個執行緒鎖物件
lock = threading.Lock()
def lock_thread(money):
    # acquire捕獲
    # 加鎖
    lock.acquire()
    time.sleep(random.randint(1,3))
    print('當前執行緒為',threading.current_thread().name)
    get_money(money)
    time.sleep(random.randint(1,3))
    print('當前執行緒為', threading.current_thread().name)
    # 解鎖
    lock.release()
# 建立執行緒的引數為一個元組型別
# 主執行緒開闢一個分執行緒
thread1 = threading.Thread(target=lock_thread,name='thread1',args=(1000,))
thread2 = threading.Thread(target=lock_thread,name='thread2',args=(2000,))
thread1.start()
thread2.start()
print('hello world')

# join 注重的整體，執行緒1沒有執行完，執行緒2不能執行
# lock 注重的是區域性 某一個變數沒有用完，其他執行緒不能使用
# thread1.join()
# thread2.join()
 

         執行緒佇列：首先引入一個包 import queue

import queue
# 建立一個執行緒佇列
# 佇列 ：first in first out 先進先出
q = queue.Queue()
for i in range(5):
    # 將內容放入到執行緒佇列中
    q.put(i)
while not q.empty():
    print(q.get())
# LIFO last in first out 後進先出
p = queue.LifoQueue()
for i in range(5):
    p.put(i)
while not p.empty():
    print(p.get())

二、yield與return的區別

       return和yield的區別：（1）return可以往法外傳遞一個值 ，從之後return之後的程式碼不再執行

                                         （2）yield 也可以往方法裡面傳遞一個值，但是傳遞之後繼續執行後面的程式碼；並且通過yield傳遞的值

                                                  的方法是一個可迭代物件。

#return

def test1(name):
    print('return方法')
    return name
    print('return方法結束')
name = test1('zhangsan')
print(name)

# yield
def test2(age):
    for i in range(age):
        yield i
        print('hello')
for x in test2(18):
    print('x=',x)