Python_線程

来源:https://www.cnblogs.com/Golanguage/archive/2020/03/02/12398013.html
-Advertisement-
Play Games

線程概念的引入背景 進程 之前我們已經瞭解了操作系統中進程的概念，程式並不能單獨運行，只有將程式裝載到記憶體中，系統為它分配資源才能運行，而這種執行的程式就稱之為進程。程式和進程的區別就在於：程式是指令的集合，它是進程運行的靜態描述文本；進程是程式的一次執行活動，屬於動態概念。在多道編程中，我們允許多 ...


線程概念的引入背景

進程

　　之前我們已經瞭解了操作系統中進程的概念，程式並不能單獨運行，只有將程式裝載到記憶體中，系統為它分配資源才能運行，而這種執行的程式就稱之為進程。程式和進程的區別就在於：程式是指令的集合，它是進程運行的靜態描述文本；進程是程式的一次執行活動，屬於動態概念。在多道編程中，我們允許多個程式同時載入到記憶體中，在操作系統的調度下，可以實現併發地執行。這是這樣的設計，大大提高了CPU的利用率。進程的出現讓每個用戶感覺到自己獨享CPU，因此，進程就是為了在CPU上實現多道編程而提出的。

有了進程為什麼要有線程

　　進程有很多優點，它提供了多道編程，讓我們感覺我們每個人都擁有自己的CPU和其他資源，可以提高電腦的利用率。很多人就不理解了，既然進程這麼優秀，為什麼還要線程呢？其實，仔細觀察就會發現進程還是有很多缺陷的，主要體現在兩點上：

  • 進程只能在一個時間乾一件事，如果想同時乾兩件事或多件事，進程就無能為力了。

  • 進程在執行的過程中如果阻塞，例如等待輸入，整個進程就會掛起，即使進程中有些工作不依賴於輸入的數據，也將無法執行。

　　如果這兩個缺點理解比較困難的話，舉個現實的例子也許你就清楚了：如果把我們上課的過程看成一個進程的話，那麼我們要做的是耳朵聽老師講課，手上還要記筆記，腦子還要思考問題，這樣才能高效的完成聽課的任務。而如果只提供進程這個機制的話，上面這三件事將不能同時執行，同一時間只能做一件事，聽的時候就不能記筆記，也不能用腦子思考，這是其一；如果老師在黑板上寫演算過程，我們開始記筆記，而老師突然有一步推不下去了，阻塞住了，他在那邊思考著，而我們呢，也不能幹其他事，即使你想趁此時思考一下剛纔沒聽懂的一個問題都不行，這是其二。

　　現在你應該明白了進程的缺陷了，而解決的辦法很簡單，我們完全可以讓聽、寫、思三個獨立的過程，並行起來，這樣很明顯可以提高聽課的效率。而實際的操作系統中，也同樣引入了這種類似的機制——線程。

線程的出現

　　60年代，在OS中能擁有資源和獨立運行的基本單位是進程，然而隨著電腦技術的發展，進程出現了很多弊端，一是由於進程是資源擁有者，創建、撤消與切換存在較大的時空開銷，因此需要引入輕型進程；二是由於對稱多處理機（SMP）出現，可以滿足多個運行單位，而多個進程並行開銷過大。 　　因此在80年代，出現了能獨立運行的基本單位——線程（Threads）。 　　註意：進程是資源分配的最小單位,線程是CPU調度的最小單位. 　　　　　每一個進程中至少有一個線程。　

進程和線程的關係

　　

　　線程與進程的區別可以歸納為以下4點： 　　1）地址空間和其它資源（如打開文件）：進程間相互獨立，同一進程的各線程間共用。某進程內的線程在其它進程不可見。 　　2）通信：進程間通信IPC，線程間可以直接讀寫進程數據段（如全局變數）來進行通信——需要進程同步和互斥手段的輔助，以保證數據的一致性。 　　3）調度和切換：線程上下文切換比進程上下文切換要快得多。 　　4）在多線程操作系統中，進程不是一個可執行的實體。 　　*通過漫畫瞭解線程進城

線程的特點

　　在多線程的操作系統中，通常是在一個進程中包括多個線程，每個線程都是作為利用CPU的基本單位，是花費最小開銷的實體。線程具有以下屬性。 　　1）輕型實體 　　線程中的實體基本上不擁有系統資源，只是有一點必不可少的、能保證獨立運行的資源。 　　線程的實體包括程式、數據和TCB。線程是動態概念，它的動態特性由線程式控制制塊TCB（Thread Control Block）描述。 
TCB包括以下信息：
（1）線程狀態。
（2）當線程不運行時，被保存的現場資源。
（3）一組執行堆棧。
（4）存放每個線程的局部變數主存區。
（5）訪問同一個進程中的主存和其它資源。
用於指示被執行指令序列的程式計數器、保留局部變數、少數狀態參數和返回地址等的一組寄存器和堆棧。
TCB包括以下信息 　　2）獨立調度和分派的基本單位。 　　在多線程OS中，線程是能獨立運行的基本單位，因而也是獨立調度和分派的基本單位。由於線程很“輕”，故線程的切換非常迅速且開銷小（在同一進程中的）。 　　3）共用進程資源。 　　線程在同一進程中的各個線程，都可以共用該進程所擁有的資源，這首先表現在：所有線程都具有相同的進程id，這意味著，線程可以訪問該進程的每一個記憶體資源；此外，還可以訪問進程所擁有的已打開文件、定時器、信號量機構等。由於同一個進程內的線程共用記憶體和文件，所以線程之間互相通信不必調用內核。 　　4）可併發執行。 　　在一個進程中的多個線程之間，可以併發執行，甚至允許在一個進程中所有線程都能併發執行；同樣，不同進程中的線程也能併發執行，充分利用和發揮了處理機與外圍設備並行工作的能力。 　　

使用線程的實際場景

 

　　開啟一個字處理軟體進程，該進程肯定需要辦不止一件事情，比如監聽鍵盤輸入，處理文字，定時自動將文字保存到硬碟，這三個任務操作的都是同一塊數據，因而不能用多進程。只能在一個進程里併發地開啟三個線程,如果是單線程，那就只能是，鍵盤輸入時，不能處理文字和自動保存，自動保存時又不能輸入和處理文字。

記憶體中的線程

 

　　多個線程共用同一個進程的地址空間中的資源，是對一臺電腦上多個進程的模擬，有時也稱線程為輕量級的進程。

　　而對一臺電腦上多個進程，則共用物理記憶體、磁碟、印表機等其他物理資源。多線程的運行也多進程的運行類似，是cpu在多個線程之間的快速切換。

　　不同的進程之間是充滿敵意的，彼此是搶占、競爭cpu的關係，如果迅雷會和QQ搶資源。而同一個進程是由一個程式員的程式創建，所以同一進程內的線程是合作關係，一個線程可以訪問另外一個線程的記憶體地址，大家都是共用的，一個線程乾死了另外一個線程的記憶體，那純屬程式員腦子有問題。

　　類似於進程，每個線程也有自己的堆棧，不同於進程，線程庫無法利用時鐘中斷強制線程讓出CPU，可以調用thread_yield運行線程自動放棄cpu，讓另外一個線程運行。

　　線程通常是有益的，但是帶來了不小程式設計難度，線程的問題是：

　　1. 父進程有多個線程，那麼開啟的子線程是否需要同樣多的線程

　　2. 在同一個進程中，如果一個線程關閉了文件，而另外一個線程正準備往該文件內寫內容呢？

　　因此，在多線程的代碼中，需要更多的心思來設計程式的邏輯、保護程式的數據。

用戶級線程和內核級線程（瞭解）

　　線程的實現可以分為兩類：用戶級線程(User-Level Thread)和內核線線程(Kernel-Level Thread)，後者又稱為內核支持的線程或輕量級進程。在多線程操作系統中，各個系統的實現方式並不相同，在有的系統中實現了用戶級線程，有的系統中實現了內核級線程。 

用戶級線程

　　內核的切換由用戶態程式自己控制內核切換,不需要內核干涉，少了進出內核態的消耗，但不能很好的利用多核Cpu。

　　

　　在用戶空間模擬操作系統對進程的調度，來調用一個進程中的線程，每個進程中都會有一個運行時系統，用來調度線程。此時當該進程獲取cpu時，進程內再調度出一個線程去執行，同一時刻只有一個線程執行。

內核級線程

　　 內核級線程:切換由內核控制，當線程進行切換的時候，由用戶態轉化為內核態。切換完畢要從內核態返回用戶態；可以很好的利用smp，即利用多核cpu。windows線程就是這樣的。

　　

用戶級與內核級線程的對比

1 內核支持線程是OS內核可感知的，而用戶級線程是OS內核不可感知的。
2 用戶級線程的創建、撤消和調度不需要OS內核的支持，是在語言（如Java）這一級處理的；而內核支持線程的創建、撤消和調度都需OS內核提供支持，而且與進程的創建、撤消和調度大體是相同的。
3 用戶級線程執行系統調用指令時將導致其所屬進程被中斷，而內核支持線程執行系統調用指令時，只導致該線程被中斷。
4 在只有用戶級線程的系統內，CPU調度還是以進程為單位，處於運行狀態的進程中的多個線程，由用戶程式控制線程的輪換運行；在有內核支持線程的系統內，CPU調度則以線程為單位，由OS的線程調度程式負責線程的調度。
5 用戶級線程的程式實體是運行在用戶態下的程式，而內核支持線程的程式實體則是可以運行在任何狀態下的程式。
用戶級線程和內核級線程的區別 
優點：當有多個處理機時，一個進程的多個線程可以同時執行。
缺點：由內核進行調度。
內核線程的優缺點 
優點：
線程的調度不需要內核直接參与，控制簡單。
可以在不支持線程的操作系統中實現。
創建和銷毀線程、線程切換代價等線程管理的代價比內核線程少得多。
允許每個進程定製自己的調度演算法，線程管理比較靈活。
線程能夠利用的表空間和堆棧空間比內核級線程多。
同一進程中只能同時有一個線程在運行，如果有一個線程使用了系統調用而阻塞，那麼整個進程都會被掛起。另外，頁面失效也會產生同樣的問題。
缺點：
資源調度按照進程進行，多個處理機下，同一個進程中的線程只能在同一個處理機下分時復用
用戶級線程的優缺點

混合實現

　　用戶級與內核級的多路復用，內核同一調度內核線程，每個內核線程對應n個用戶線程

　　

linux操作系統的 NPTL　　　　

歷史
在內核2.6以前的調度實體都是進程，內核並沒有真正支持線程。它是能過一個系統調用clone()來實現的，這個調用創建了一份調用進程的拷貝，跟fork()不同的是,這份進程拷貝完全共用了調用進程的地址空間。LinuxThread就是通過這個系統調用來提供線程在內核級的支持的(許多以前的線程實現都完全是在用戶態，內核根本不知道線程的存在)。非常不幸的是，這種方法有相當多的地方沒有遵循POSIX標準，特別是在信號處理，調度，進程間通信原語等方面。

很顯然，為了改進LinuxThread必須得到內核的支持，並且需要重寫線程庫。為了實現這個需求，開始有兩個相互競爭的項目：IBM啟動的NGTP(Next Generation POSIX Threads)項目，以及Redhat公司的NPTL。在2003年的年中，IBM放棄了NGTP，也就是大約那時，Redhat發佈了最初的NPTL。

NPTL最開始在redhat linux 9里發佈，現在從RHEL3起內核2.6起都支持NPTL，並且完全成了GNU C庫的一部分。

 

設計
NPTL使用了跟LinuxThread相同的辦法，在內核裡面線程仍然被當作是一個進程，並且仍然使用了clone()系統調用(在NPTL庫里調用)。但是，NPTL需要內核級的特殊支持來實現，比如需要掛起然後再喚醒線程的線程同步原語futex.

NPTL也是一個1*1的線程庫，就是說，當你使用pthread_create()調用創建一個線程後，在內核里就相應創建了一個調度實體，在linux里就是一個新進程，這個方法最大可能的簡化了線程的實現。

除NPTL的1*1模型外還有一個m*n模型，通常這種模型的用戶線程數會比內核的調度實體多。在這種實現里，線程庫本身必須去處理可能存在的調度，這樣線上程庫內部的上下文切換通常都會相當的快，因為它避免了系統調用轉到內核態。然而這種模型增加了線程實現的複雜性,並可能出現諸如優先順序反轉的問題，此外，用戶態的調度如何跟內核態的調度進行協調也是很難讓人滿意。
介紹

線程和python

理論知識

全局解釋器鎖GIL

　　Python代碼的執行由Python虛擬機(也叫解釋器主迴圈)來控制。Python在設計之初就考慮到要在主迴圈中，同時只有一個線程在執行。雖然 Python 解釋器中可以“運行”多個線程，但在任意時刻只有一個線程在解釋器中運行。
　　對Python虛擬機的訪問由全局解釋器鎖(GIL)來控制，正是這個鎖能保證同一時刻只有一個線程在運行。

　　在多線程環境中，Python 虛擬機按以下方式執行：

　　a、設置 GIL；

　　b、切換到一個線程去運行；

　　c、運行指定數量的位元組碼指令或者線程主動讓出控制(可以調用 time.sleep(0))；

　　d、把線程設置為睡眠狀態；

　　e、解鎖 GIL；

　　d、再次重覆以上所有步驟。
　　在調用外部代碼(如 C/C++擴展函數)的時候，GIL將會被鎖定，直到這個函數結束為止(由於在這期間沒有Python的位元組碼被運行，所以不會做線程切換)編寫擴展的程式員可以主動解鎖GIL。

python線程模塊的選擇

　　Python提供了幾個用於多線程編程的模塊，包括thread、threading和Queue等。thread和threading模塊允許程式員創建和管理線程。thread模塊提供了基本的線程和鎖的支持，threading提供了更高級別、功能更強的線程管理的功能。Queue模塊允許用戶創建一個可以用於多個線程之間共用數據的隊列數據結構。
　　避免使用thread模塊，因為更高級別的threading模塊更為先進，對線程的支持更為完善，而且使用thread模塊里的屬性有可能會與threading出現衝突；其次低級別的thread模塊的同步原語很少(實際上只有一個)，而threading模塊則有很多；再者，thread模塊中當主線程結束時，所有的線程都會被強制結束掉，沒有警告也不會有正常的清除工作，至少threading模塊能確保重要的子線程退出後進程才退出。 

　　thread模塊不支持守護線程，當主線程退出時，所有的子線程不論它們是否還在工作，都會被強行退出。而threading模塊支持守護線程，守護線程一般是一個等待客戶請求的伺服器，如果沒有客戶提出請求它就在那等著，如果設定一個線程為守護線程，就表示這個線程是不重要的，在進程退出的時候，不用等待這個線程退出。

threading模塊

multiprocess模塊的完全模仿了threading模塊的介面，二者在使用層面，有很大的相似性，因而不再詳細介紹（官方鏈接）

線程的創建Threading.Thread類

線程的創建

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('egon',))
    t.start()
    print('主線程')
創建線程的方式1 
from threading import Thread
import time
class Sayhi(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        time.sleep(2)
        print('%s say hello' % self.name)


if __name__ == '__main__':
    t = Sayhi('egon')
    t.start()
    print('主線程')
創建線程的方式2

多線程與多進程

from threading import Thread
from multiprocessing import Process
import os

def work():
    print('hello',os.getpid())

if __name__ == '__main__':
    #part1:在主進程下開啟多個線程,每個線程都跟主進程的pid一樣
    t1=Thread(target=work)
    t2=Thread(target=work)
    t1.start()
    t2.start()
    print('主線程/主進程pid',os.getpid())

    #part2:開多個進程,每個進程都有不同的pid
    p1=Process(target=work)
    p2=Process(target=work)
    p1.start()
    p2.start()
    print('主線程/主進程pid',os.getpid())
pid的比較 
from threading import Thread
from multiprocessing import Process
import os

def work():
    print('hello')

if __name__ == '__main__':
    #在主進程下開啟線程
    t=Thread(target=work)
    t.start()
    print('主線程/主進程')
    '''
    列印結果:
    hello
    主線程/主進程
    '''

    #在主進程下開啟子進程
    t=Process(target=work)
    t.start()
    print('主線程/主進程')
    '''
    列印結果:
    主線程/主進程
    hello
    '''
開啟效率的較量 
from  threading import Thread
from multiprocessing import Process
import os
def work():
    global n
    n=0

if __name__ == '__main__':
    # n=100
    # p=Process(target=work)
    # p.start()
    # p.join()
    # print('主',n) #毫無疑問子進程p已經將自己的全局的n改成了0,但改的僅僅是它自己的,查看父進程的n仍然為100


    n=1
    t=Thread(target=work)
    t.start()
    t.join()
    print('主',n) #查看結果為0,因為同一進程內的線程之間共用進程內的數據
同一進程內的線程共用該進程的數據？
記憶體數據的共用問題

練習 ：多線程實現socket

#_*_coding:utf-8_*_
#!/usr/bin/env python
import multiprocessing
import threading

import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('127.0.0.1',8080))
s.listen(5)

def action(conn):
    while True:
        data=conn.recv(1024)
        print(data)
        conn.send(data.upper())

if __name__ == '__main__':

    while True:
        conn,addr=s.accept()


        p=threading.Thread(target=action,args=(conn,))
        p.start()
server 
#_*_coding:utf-8_*_
#!/usr/bin/env python


import socket

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('127.0.0.1',8080))

while True:
    msg=input('>>: ').strip()
    if not msg:continue

    s.send(msg.encode('utf-8'))
    data=s.recv(1024)
    print(data)
client

Thread類的其他方法

複製代碼 
Thread實例對象的方法
  # isAlive(): 返回線程是否活動的。
  # getName(): 返回線程名。
  # setName(): 設置線程名。

threading模塊提供的一些方法：
  # threading.currentThread(): 返回當前的線程變數。
  # threading.enumerate(): 返回一個包含正在運行的線程的list。正在運行指線程啟動後、結束前，不包括啟動前和終止後的線程。
  # threading.activeCount(): 返回正在運行的線程數量，與len(threading.enumerate())有相同的結果。
複製代碼 
from threading import Thread
import threading
from multiprocessing import Process
import os

def work():
    import time
    time.sleep(3)
    print(threading.current_thread().getName())


if __name__ == '__main__':
    #在主進程下開啟線程
    t=Thread(target=work)
    t.start()

    print(threading.current_thread().getName())
    print(threading.current_thread()) #主線程
    print(threading.enumerate()) #連同主線程在內有兩個運行的線程
    print(threading.active_count())
    print('主線程/主進程')

    '''
    列印結果:
    MainThread
    <_MainThread(MainThread, started 140735268892672)>
    [<_MainThread(MainThread, started 140735268892672)>, <Thread(Thread-1, started 123145307557888)>]
    主線程/主進程
    Thread-1
    '''
代碼示例 
from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('egon',))
    t.start()
    t.join()
    print('主線程')
    print(t.is_alive())
    '''
    egon say hello
    主線程
    False
    '''
join方法

守護線程

無論是進程還是線程，都遵循：守護xx會等待主xx運行完畢後被銷毀。需要強調的是：運行完畢並非終止運行

#1.對主進程來說，運行完畢指的是主進程代碼運行完畢
#2.對主線程來說，運行完畢指的是主線程所在的進程內所有非守護線程統統運行完畢，主線程才算運行完畢
#1 主進程在其代碼結束後就已經算運行完畢了（守護進程在此時就被回收）,然後主進程會一直等非守護的子進程都運行完畢後回收子進程的資源(否則會產生僵屍進程)，才會結束，
#2 主線程在其他非守護線程運行完畢後才算運行完畢（守護線程在此時就被回收）。因為主線程的結束意味著進程的結束，進程整體的資源都將被回收，而進程必須保證非守護線程都運行完畢後才能結束。
詳細解釋 
from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('egon',))
    t.setDaemon(True) #必須在t.start()之前設置
    t.start()

    print('主線程')
    print(t.is_alive())
    '''
    主線程
    True
    '''
守護線程例1 
from threading import Thread
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")


t1=Thread(target=foo)
t2=Thread(target=bar)

t1.daemon=True
t1.start()
t2.start()
print("main-------")
守護線程例2

鎖

鎖與GIL

 

同步鎖

from threading import Thread
import os,time
def work():
    global n
    temp=n
    time.sleep(0.1)
    n=temp-1
if __name__ == '__main__':
    n=100
    l=[]
    for i in range(100):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n) #結果可能為99
多個線程搶占資源的情況 複製代碼 
import threading
R=threading.Lock()
R.acquire()
'''
對公共數據的操作
'''
R.release()
複製代碼 
from threading import Thread,Lock
import os,time
def work():
    global n
    lock.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    lock.release()
if __name__ == '__main__':
    lock=Lock()
    n=100
    l=[]
    for i in range(100):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n) #結果肯定為0，由原來的併發執行變成串列，犧牲了執行效率保證了數據安全
同步鎖的引用 
#不加鎖:併發執行,速度快,數據不安全
from threading import current_thread,Thread,Lock
import os,time
def task():
    global n
    print('%s is running' %current_thread().getName())
    temp=n
    time.sleep(0.5)
    n=temp-1


if __name__ == '__main__':
    n=100
    lock=Lock()
    threads=[]
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()

    stop_time=time.time()
    print('主:%s n:%s' %(stop_time-start_time,n))

'''
Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:0.5216062068939209 n:99
'''


#不加鎖:未加鎖部分併發執行,加鎖部分串列執行,速度慢,數據安全
from threading import current_thread,Thread,Lock
import os,time
def task():
    #未加鎖的代碼併發運行
    time.sleep(3)
    print('%s start to run' %current_thread().getName())
    global n
    #加鎖的代碼串列運行
    lock.acquire()
    temp=n
    time.sleep(0.5)
    n=temp-1
    lock.release()

if __name__ == '__main__':
    n=100
    lock=Lock()
    threads=[]
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    stop_time=time.time()
    print('主:%s n:%s' %(stop_time-start_time,n))

'''
Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:53.294203758239746 n:0
'''

#有的同學可能有疑問:既然加鎖會讓運行變成串列,那麼我在start之後立即使用join,就不用加鎖了啊,也是串列的效果啊
#沒錯:在start之後立刻使用jion,肯定會將100個任務的執行變成串列,毫無疑問,最終n的結果也肯定是0,是安全的,但問題是
#start後立即join:任務內的所有代碼都是串列執行的,而加鎖,只是加鎖的部分即修改共用數據的部分是串列的
#單從保證數據安全方面,二者都可以實現,但很明顯是加鎖的效率更高.
from threading import current_thread,Thread,Lock
import os,time
def task():
    time.sleep(3)
    print('%s start to run' %current_thread().getName())
    global n
    temp=n
    time.sleep(0.5)
    n=temp-1


if __name__ == '__main__':
    n=100
    lock=
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • ZYNQ自定義AXI匯流排IP應用——PWM實現呼吸燈效果
    一、前言 在實時性要求較高的場合中，CPU軟體執行的方式顯然不能滿足需求，這時需要硬體邏輯實現部分功能。要想使自定義IP核被CPU訪問，就必須帶有匯流排介面。ZYNQ採用AXI BUS實現PS和PL之間的數據交互。本文以PWM為例設計了自定義AXI匯流排IP，來演示如何靈活運用ARM+FPGA的架構。 ...
  • [伺服器] 寶塔面板與Python3的恩怨情仇
    問題描述 伺服器鏡像有寶塔面板 + Python2，用yum和pip3安裝Python3 + Flask + Gunicorn後，寶塔面板打不開了。報錯如下： 報錯早就刷上去了，找不回來，這段照搬別人的[^引用1]，因為看著差不了多少。 其實我的情況跟引用1差不多，但是就是最後一步依然報錯。 修複 ...
  • 阿裡內部技術精選文檔，需要的可以自己保存起來
    由於細節內容實在太多啦，所以只把部分知識點截圖出來粗略的介紹，每個小節點裡面都有更細化的內容！ 內容簡介 這套書同時收錄了十多位阿裡技術人的訪談：從工程師到合伙人的多隆，6 年時間影響數億用戶的靖世，入選 MIT2017 年度 TR35 的王剛 &吳翰清，免試晉升為研究員的錢磊等，將為你展現不一樣的 ...
  • 《自拍教程33》思維篇_內容介紹
    當前測試人員的主要矛盾： Python基礎語法都看了學了幾遍了。 用不上，不會寫，網上的例子又大部分是面向開發人員的， 好多都是人工智慧，大數據，區塊鏈，或者數學演算法題。 偶爾有Selenium面向Web測試人員， 但是Selenium作為Python入門實例， 也不合適，因為還是太難了。 武散人的 ...
  • Have Fun with Numbers
    題目 第一次做全英文編程題（辭彙量嚴重不足，還需多記單詞）； 題目的大致意思就是說：輸入一個不超過20位的整數，將這個數乘以2，比較計算前和計算後的結果是否滿足題目的要求， 這個要求具體是指判斷組成這兩個數的具體數字出現的次數是否相等，例如:這個數為123456789，它乘以2之後得到2469135 ...
  • django 基礎
    基本配置 一、創建django程式 終端命令： django-admin startproject sitename IDE創建django程式時，本質上都是自動執行上述命令 其他常用命令：進入工程目錄 python manage.py runserver 127.0.0.1 埠號 運行測試 py ...
  • Python操作MySQL
    資料庫的安裝和連接 PyMySQL的安裝 pip install PyMySQL python連接資料庫 import pymysql db = pymysql.connect("資料庫ip","用戶","密碼","資料庫" ) 打開資料庫連接 cursor.execute("SELECT VERS ...
  • Python_協程
    引子 之前我們學習了線程、進程的概念，瞭解了在操作系統中進程是資源分配的最小單位,線程是CPU調度的最小單位。按道理來說我們已經算是把cpu的利用率提高很多了。但是我們知道無論是創建多進程還是創建多線程來解決問題，都要消耗一定的時間來創建進程、創建線程、以及管理他們之間的切換。 隨著我們對於效率的追 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類