線程基礎和用法

目錄

• 1、線程
• 2、開啓線程的倆種方式
  • 2.1方式1
  • 2.2方式2
• 3、子進程vs子線程建立速度
• 4、子線程共享資源
• 5、線程的jion方法
  • 5.1方法1
  • 5.2方法2
  • 5.3瞭解進程的jion
• 6、守護線程
• 7、線程其餘的相關用法

1、線程

1. 初識線程
   在傳統操做系統種，每一個進程有一個地址空間，並且默認就有一個控制線程，cpu真正的執行單位是線程。
   在工廠中，每個車間都有房子，並且每一個車間默認就有一個流水線。

2. 作一個比較

   ​ 至關於
   操做系統------->工廠
   進程------->車間
   線程------->流水線
   cpu------->電源

3. 線程：cpu最小的執行單位
   進程：資源集合/資源單位
   線程運行 ------->代碼運行
   進程運行------->各類資源 + 線程

4. 右鍵運行會發生的事情：申請內存空間，先將解釋器代碼丟進去而且把python代碼丟進去（進程作的）（內存運行的時候不識別python文件代碼，只有解釋器才能識別python文件代碼，全部先把解釋器放入內存），運行代碼（線程）

5. 進程和線程的區別：
   過程描述的區別
   線程------->單指代碼的執行過程
   進程------->資源的申請與銷燬的過程

6. 進程內存空間彼此隔離（內存共享or隔離）

   多個進程內存空間彼此隔離。

   同一進程下的多個線程共享該進程內的數據。同一個進程下的線程共享資源

7. 進程和線程的創造速度
   進程須要申請資源開闢空間------->慢
   只是告訴操做系統一個執行方案------->快

8. 1 進程的啓動和銷燬（空間開始和釋放）

   只要一說一個進程啓動了，那你知道了一個事情，是關於這個程序的一塊空間造好了。

   只要一說進程銷燬了，那你也知道了一個事情，是關於這個程序的空間釋放了。

   2 線程的啓動和銷燬（進程裏的一段代碼運行起來了，進程裏的一段代碼運行結束）

9. 進程之間是競爭關係，線程之間是協做關係？（瞭解）

   車間直接是競爭/搶電源的關係，競爭（不一樣的進程直接是競爭關係，是不一樣的程序員寫的程序運行的，迅雷搶佔其餘進程的網速，360把其餘進程當作病毒乾死）
   一個車間的不一樣流水線式協同工做的關係（同一個進程的線程之間是合做關係，是同一個程序寫的程序內開啓動，迅雷內的線程是合做關係，不會本身幹本身）

2、開啓線程的倆種方式

因爲線程開啓不會出現一直循環調用開啓的狀況和進程是不一樣的，因此不須要用main來隔絕，但能夠使用。

2.1方式1

from threading import Thread
import time
def task():
    print('線程 start')
    time.sleep(2)
    print('線程end')
if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    print('主進程')
################
線程 start
主進程
線程end

2.2方式2

from threading import Thread
import time
class Myt(Thread):
    def run(self):
        print('子進程 start')
        time.sleep(2)
        print('子進程 end')
t = Myt()
t.start()
print('主')
#######################
子進程 start
主
子進程 end

3、子進程vs子線程建立速度

from threading import Thread
from multiprocessing import Process
import time


def task(name):
    print(f'{name} is runing')
    time.sleep(2)
    print(f'{name} is endding')


if __name__ == '__main__':
    t= Thread(target=task,args=('子線程',))
    p = Process(target=task,args=('子進程',))
    t.start()
    p.start()
    print('主')
##########################
子線程 is runing
主
子進程 is runing
子線程 is endding
子進程 is endding

from threading import Thread
from multiprocessing import Process
import time


def task(name):
    print(f'{name} is runing')
    time.sleep(2)
    print(f'{name} is endding')


if __name__ == '__main__':
    t= Thread(target=task,args=('子線程',))
    # p = Process(target=task,args=('子進程',))
    t.start()
    # p.start()
    print('主')
#######################
子線程 is runing
主
子線程 is endding

from threading import Thread
from multiprocessing import Process
import time


def task(name):
    print(f'{name} is runing')
    time.sleep(2)
    print(f'{name} is endding')


if __name__ == '__main__':
    # t= Thread(target=task,args=('子線程',))
    p = Process(target=task,args=('子進程',))
    # t.start()
    p.start()
    print('主')
##################
主
子進程 is runing
子進程 is endding

4、子線程共享資源

from threading import Thread
import time,os
x = 100
def task():
    global x
    x = 50
    print(os.getpid())
if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    time.sleep(2)
    print(x)
    print(os.getpid())#處於一個進程，因此pid是同樣的
###########
16656
50
16656

5、線程的jion方法

5.1方法1

from threading import Thread
import time
def task():
    print('子線程 start')
    time.sleep(2)
    print('子線程 end')
t = Thread(target=task)
t.start()
t.join()#等待子線程運行結束
print('主線程')
################
子線程 start
子線程 end
主線程

思考主線程是否會等子線程運行結束

1 實際上是進程在等
貌似是主線程在原地等着，主線程已經運行完。
原來沒有子線程的狀況下，其實就一個主線程這一條流水線工做完了，這個進程就結束了。
那如今的狀況是當前進程有其餘的子線程，是進程等待本身全部的子線程運行完。

# 主進程等子進程是由於主進程要給子進程收屍
# 如今看到的等是進程必須等待其內部全部線程都運行完畢才結束。

5.2方法2

from threading import Thread
import time
def task(name,n):
    print(f'{name} start')
    time.sleep(n)
    print(f'{name} end')
t1 = Thread(target=task,args=('線程1',1))
t2 = Thread(target=task,args=('線程2',2))
t3 = Thread(target=task,args=('線程3',3))
start = time.time()
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
end = time.time()
print(end-start)
##########################
線程1 start
線程2 start
線程3 start
線程1 end
線程2 end
線程3 end
3.0029337406158447

5.3瞭解進程的jion

from multiprocessing import Process
from threading import Thread

import time
def task():
    print('進程 start')
    time.sleep(10)
    print('進程  end')
def task2():
    print('子線程 start')
    time.sleep(3)
    print('子線程 end')
if __name__ == '__main__':
    p = Process(target=task)
    t = Thread(target=task2)
    t.start()
    p.start()
    print('子進程的join開始')
    p.join()#主進程的主線程等待子進程運行結束
    print('主')
##################
子線程 start
子進程的join開始
進程 start
子線程 end
進程  end
主

6、守護線程

# 守護線程首先是一個線程。
    # 守護線程守護到當前進程運行結束。
    # ps:好比有未完成的子進程階段會守護，好比有未完成的其餘子線程也均會守護。
# 守護進程首先是一個進程。
    # 守護進程守護到當前進程的最後一行代碼結束。

from threading import Thread,enumerate,currentThread
import time
def task():
    print('守護線程開始')
    print(currentThread())
    time.sleep(10)
    print('守護線程end')
def task2():
    print('子線程 start')
    time.sleep(5)
    print(enumerate())
    print('子線程 end')
if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task2)
    t1.daemon = True
    t2.start()
    t1.start()
    print('主')
####################
子線程 start
守護線程開始
<Thread(Thread-1, started daemon 13904)>
主
[<_MainThread(MainThread, stopped 13828)>, <Thread(Thread-2, started 3316)>, <Thread(Thread-1, started daemon 13904)>]
子線程 end

7、線程其餘的相關用法

Thread實例對象的方法

1. isAlive(): 返回線程是否活動的。
2. getName(): 返回線程名。
3. setName(): 設置線程名。

threading模塊提供的一些方法：

1. threading.currentThread(): 返回當前的線程變量。
2. threading.enumerate(): 返回一個包含正在運行的線程的list。正在運行指線程啓動後、結束前，不包括啓動前和終止後的線程。
3. threading.activeCount(): 返回正在運行的線程數量，與len(threading.enumerate())有相同的結果

• isalive()

  from threading import Thread,currentThread,enumerate,activeCount
  import time
  def task():
      print('子線程 start')
      time.sleep(2)
      print('子線程  end')
  if __name__ == '__main__':
      t1 = Thread(target=task)
      t2 = Thread(target=task)
      t1.start()
      t2.start()
  
  
      print(t1.is_alive())#子線程存在，True
  #################
  子線程 start
  子線程 start
  True
  子線程  end
  子線程  end

• getname()

  from threading import Thread,currentThread,enumerate,activeCount
  import time
  def task():
      print('子線程 start')
      time.sleep(2)
      print('子線程  end')
  if __name__ == '__main__':
      t1 = Thread(target=task)
      t1.start()
  
  
      print(t1.getName())
  
  ##########################
  子線程 start
  Thread-1
  子線程  end

• setname()

  from threading import Thread,currentThread,enumerate,activeCount
  import time
  def task():
      print('子線程 start')
      time.sleep(2)
      print('子線程  end')
  if __name__ == '__main__':
      t1 = Thread(target=task)
      t1.start()
  
      t1.setName('線程1')
      print(t1.getName())
  #####################
  子線程 start
  線程1
  子線程  end

• currentTread()

• enumerate()

  from threading import Thread,currentThread,enumerate,activeCount
  import time
  def task():
      print('子線程 start')
      time.sleep(2)
      print('子線程  end')
      print(enumerate())
  if __name__ == '__main__':
      t1 = Thread(target=task)
      t2 = Thread(target=task)
      t1.start()
      t2.start()
  ###################################
  子線程 start
  子線程 start
  子線程  end
  [<_MainThread(MainThread, stopped 12328)>, <Thread(Thread-1, started 6176)>, <Thread(Thread-2, started 14452)>]
  子線程  end
  [<_MainThread(MainThread, stopped 12328)>, <Thread(Thread-2, started 14452)>]

  from threading import Thread,currentThread,enumerate,activeCount
  import time
  def task():
      print('子線程 start')
      time.sleep(2)
      print('子線程  end')
  if __name__ == '__main__':
      t1 = Thread(target=task)
      t2 = Thread(target=task)
      t1.start()
      t2.start()
      print(enumerate())
  ########################
  子線程 start
  子線程 start
  [<_MainThread(MainThread, started 16964)>, <Thread(Thread-1, started 15796)>, <Thread(Thread-2, started 15476)>]
  子線程  end
  子線程  end

• activeCount()與len(enumerate())

  from threading import Thread,currentThread,enumerate,activeCount
  import time
  def task():
      print('子線程 start')
      time.sleep(2)
      print('子線程  end')
  if __name__ == '__main__':
      t1 = Thread(target=task)
      t2 = Thread(target=task)
      t1.start()
      t2.start()
      print(activeCount())
      print(len(enumerate()))
  #################
  子線程 start
  子線程 start
  3
  3
  子線程  end
  子線程  end

• 1

  from threading import Thread,currentThread,enumerate,activeCount
  import time
  def task():
      print('子線程 start')
      time.sleep(2)
      print('子線程  end')
  if __name__ == '__main__':
      t1 = Thread(target=task)
      t2 = Thread(target=task)
      t1.start()
      t2.start()
      print(currentThread())
      print(currentThread().name)
  ##################
  子線程 start
  子線程 start
  <_MainThread(MainThread, started 2696)>
  MainThread
  子線程  end
  子線程  end