pythonmonitor

『壹』 python利器——pipenv和pyenv介紹

也可以看我CSDN的博客:
https://blog.csdn.net/u013332124/article/details/90049921

在寫python程序時，經常會被版本管理以及第三方包管理搞的很頭疼。這兩天看了業內相關的解決方案，覺的很不錯。

我們經常在開發時會需要用到多個python版本，為了解決版本問題，比較常見的做法是修改環境變數來切換版本，但是修改環境變數終究比較麻煩。另外，我們在安裝新的python版本時也會小心翼翼，避免影響到系統自帶的python版本。這個問題都可以通過pyenv來解決。

pyenv可以在系統中安裝多個python版本，並且不影響到系統自帶的python，而且通過pyenv我們可以快速的在多個python版本之間來回切換 。

安裝pyenv之前需要保證電腦上已經安裝了git:

安裝好了之後，使用很簡單，比如我們要安裝python3.7.3的版本，可以直接通過pyenv安裝

之後可以通過以下命令快速切換python命令

其實pyenv的原理也很簡單，就是對python版本進行統一管理，之後也是通過修改環境變數來切換python命令的指向。但是通過pyenv我們只要執行一個命令就可以了，我們可以看到所有通過pyenv安裝的python版本都放在 ~/.pyenv/versions 目錄下，也更加方便管理

pyenv 支持的參數也比較少:

shell表示切換的版本僅當前版本有效,session關閉後就失效了

global表示全局,重啟也不會影響更改

local表示臨時生效，但是系統重啟後就不會生效了

pyenv雖然解決了python版本切換的問題，但是依舊無法解決各個項目的第三方包管理的問題。比如說A項目需要用requests版本是1.0，而B項目需要requests版本是2.0。這時候pipenv就派上用場了。值得一提的是，pipenv也是寫requests的那位大佬寫的。

pipenv可以為我們的項目自動創建和管理一個虛擬環境 。並且會在項目目錄下創建一個Pipfile來管理第三方包。

pipenv的安裝很簡單:

使用也很簡單，進入項目目錄後，使用以下任一命令創建一個虛擬環境:

創建成功後會在項目目錄下生產一個Pipfile文件來管理第三方包。之後可以通過以下命令安裝requests

這樣requests的安裝只對當前項目生效 。之後可以通過以下命令進行虛擬環境運行相關腳本：

或者通過以下命令直接使用虛擬環境運行命令:

pipenv的原理也很簡單，我們輸入 pipenv -venv 就可以得到虛擬環境的目錄。然後在執行pipenv shell時，會看到以下輸出語句:

其實就是激活虛擬環境的activate，設置一下相關環境變數。通過pipenv安裝的第三方包也都在 ~/.local/share/virtualenvs/monitor-9E5KrdNU/lib 目錄下。

有了pipenv後，其實virtualenv已經沒什麼用了。但是也有人在線上部署的時候結合virtualenv和pipenv來部署，因此這里做個簡單的介紹。

安裝virtualenv也很簡單：

之後創建一個虛擬環境：

其實就是創建了一個venv的目錄，這個目錄下有bin、lib、include，其中通過虛擬環境安裝的第三方包都會放在lib下。

通過以下命令進入虛擬環境：

和pipenv基本一樣，就是通過activate設置了環境變數。

之後通過 deactivate 退出虛擬環境，其實就是恢復了環境變數。

使用pipenv在本地開發好後，總要部署到線上。如果線上也能直接安裝pipenv固然最好，但是不好在伺服器安裝pipenv的情況，怎麼辦呢？

1、如果線上使用的是virtualenv管理虛擬環境的話

可以直接在virtualenv的虛擬環境中安裝pipenv，這樣就可以直接運行我們基於pipenv構建的項目了

2、 如果線上連virtualenv都沒有的話

通過pipenv導出requirements.txt，然後到線上安裝第三方包

pipenv介紹

pyenv介紹

virtualenv介紹

『貳』 pythonmonitor.py出錯

模塊名稱拼寫錯誤
可能出現的問題：模塊名稱拼寫錯誤。解決:修改正確，沒有引入模塊。解決:使用import語句導入模塊。
Python提供了高效的高級數據結構，還能簡單有效地面向對象編程。Python語法和動態類型，以及解釋型語言的本質，使它成為多數平台上寫腳本和快速開發應用的編程語言，隨著版本的不斷更新和語言新功能的添加，逐漸被用於獨立的、大型項目的開發。

『叄』 python 運維常用腳本

Python 批量遍歷目錄文件,並修改訪問時間

import os

path = "D:/UASM64/include/"
dirs = os.listdir(path)
temp=[];

for file in dirs:
temp.append(os.path.join(path, file))
for x in temp:
os.utime(x, (1577808000, 1577808000))
Python 實現的自動化伺服器管理

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

def ssh_cmd(user,passwd,port,userfile,cmd):

def ssh_put(user,passwd,source,target):

while True:
try:
shell=str(input("[Shell] # "))
if (shell == ""):
continue
elif (shell == "exit"):
exit()
elif (shell == "put"):
ssh_put("root","123123","./a.py","/root/a.py")
elif (shell =="cron"):
temp=input("輸入一個計劃任務: ")
temp1="(crontab -l; echo "+ temp + ") |crontab"
ssh_cmd("root","123123","22","./user_ip.conf",temp1)
elif (shell == "uncron"):
temp=input("輸入要刪除的計劃任務: ")
temp1="crontab -l | grep -v " "+ temp + "|crontab"
ssh_cmd("root","123123","22","./user_ip.conf",temp1)
else:
ssh_cmd("lyshark","123123","22","./user_ip.conf",shell)

遍歷目錄和文件

import os

def list_all_files(rootdir):
import os
_files = []
list = os.listdir(rootdir) #列出文件夾下所有的目錄與文件
for i in range(0,len(list)):
path = os.path.join(rootdir,list[i])
if os.path.isdir(path):
_files.extend(list_all_files(path))
if os.path.isfile(path):
_files.append(path)
return _files

a=list_all_files("C:/Users/LyShark/Desktop/a")
print(a)
python檢測指定埠狀態

import socket

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.settimeout(1)

for ip in range(0,254):
try:
sk.connect(("192.168.1."+str(ip),443))
print("192.168.1.%d server open "%ip)
except Exception:
print("192.168.1.%d server not open"%ip)

sk.close()

python實現批量執行CMD命令

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

print("------------------------------> ")
print("使用說明,在當前目錄創建ip.txt寫入ip地址")
print("------------------------------> ")

user=input("輸入用戶名:")
passwd=input("輸入密碼:")
port=input("輸入埠:")
cmd=input("輸入執行的命令:")

file = open("./ip.txt", "r")
line = file.readlines()

for i in range(len(line)):
print("對IP: %s 執行"%line[i].strip(' '))

python3-實現釘釘報警

import requests
import sys
import json

dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='

data = {"msgtype": "markdown","markdown": {"title": "監控","text": "apche異常"}}

headers = {'Content-Type':'application/json;charset=UTF-8'}

send_data = json.mps(data).encode('utf-8')
requests.post(url=dingding_url,data=send_data,headers=headers)

import psutil
import requests
import time
import os
import json

monitor_name = set(['httpd','cobblerd']) # 用戶指定監控的服務進程名稱

proc_dict = {}
proc_name = set() # 系統檢測的進程名稱
monitor_map = {
'httpd': 'systemctl restart httpd',
'cobblerd': 'systemctl restart cobblerd' # 系統在進程down掉後，自動重啟
}

dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='

while True:
for proc in psutil.process_iter(attrs=['pid','name']):
proc_dict[proc.info['pid']] = proc.info['name']
proc_name.add(proc.info['name'])

判斷指定埠是否開放

import socket

port_number = [135,443,80]

for index in port_number:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((飗.0.0.1', index))
if result == 0:
print("Port %d is open" % index)
else:
print("Port %d is not open" % index)
sock.close()

判斷指定埠並且實現釘釘輪詢報警

import requests
import sys
import json
import socket
import time

def dingding(title,text):
dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='
data = {"msgtype": "markdown","markdown": {"title": title,"text": text}}
headers = {'Content-Type':'application/json;charset=UTF-8'}
send_data = json.mps(data).encode('utf-8')
requests.post(url=dingding_url,data=send_data,headers=headers)

def net_scan():
port_number = [80,135,443]
for index in port_number:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((飗.0.0.1', index))
if result == 0:
print("Port %d is open" % index)
else:
return index
sock.close()

while True:
dingding("Warning",net_scan())
time.sleep(60)

python-實現SSH批量CMD執行命令

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

def ssh_cmd(user,passwd,port,userfile,cmd):
file = open(userfile, "r")
line = file.readlines()
for i in range(len(line)):
print("對IP: %s 執行"%line[i].strip(' '))
ssh.connect(hostname=line[i].strip(' '),port=port,username=user,password=passwd)
cmd=cmd
stdin, stdout, stderr = ssh.exec_command(cmd)
result = stdout.read()

ssh_cmd("lyshark","123","22","./ip.txt","free -h |grep 'Mem:' |awk '{print $3}'")

用python寫一個列舉當前目錄以及所有子目錄下的文件，並列印出絕對路徑

import sys
import os

for root,dirs,files in os.walk("C://"):
for name in files:
print(os.path.join(root,name))
os.walk()

按照這樣的日期格式（xxxx-xx-xx）每日生成一個文件，例如今天生成的文件為2013-09-23.log， 並且把磁碟的使用情況寫到到這個文件中。

import os
import sys
import time

new_time = time.strftime("%Y-%m-%d")
disk_status = os.popen("df -h").readlines()

str1 = ''.join(disk_status)
f = open(new_time+'.log','w')
f.write("%s"%str1)

f.flush()
f.close()

統計出每個IP的訪問量有多少？（從日誌文件中查找）

import sys

list = []

f = open("/var/log/httpd/access_log","r")
str1 = f.readlines()
f.close()

for i in str1:
ip=i.split()[0]
list.append(ip)

list_num=set(list)

for j in list_num:
num=list.count(j)
print("%s -----> %s" %(num,j))

寫個程序，接受用戶輸入數字，並進行校驗，非數字給出錯誤提示，然後重新等待用戶輸入。

import tab
import sys

while True:
try:
num=int(input("輸入數字：").strip())
for x in range(2,num+1):
for y in range(2,x):
if x % y == 0:
break
else:
print(x)
except ValueError:
print("您輸入的不是數字")
except KeyboardInterrupt:
sys.exit(" ")

ps 可以查看進程的內存佔用大小，寫一個腳本計算一下所有進程所佔用內存大小的和。

import sys
import os

list=[]
sum=0

str1=os.popen("ps aux","r").readlines()

for i in str1:
str2=i.split()
new_rss=str2[5]
list.append(new_rss)
for i in list[1:-1]:
num=int(i)
sum=sum+num

print("%s ---> %s"%(list[0],sum))

關於Python 命令行參數argv

import sys

if len(sys.argv) < 2:
print ("沒有輸入任何參數")
sys.exit()

if sys.argv[1].startswith("-"):
option = sys.argv[1][1:]

利用random生成6位數字加字母隨機驗證碼

import sys
import random

rand=[]

for x in range(6):
y=random.randrange(0,5)
if y == 2 or y == 4:
num=random.randrange(0,9)
rand.append(str(num))
else:
temp=random.randrange(65,91)
c=chr(temp)
rand.append(c)
result="".join(rand)
print(result)

自動化-使用pexpect非交互登陸系統

import pexpect
import sys

ssh = pexpect.spawn('ssh [email protected]')
fout = file('sshlog.txt', 'w')
ssh.logfile = fout

ssh.expect("[email protected]'s password:")

ssh.sendline("密碼")
ssh.expect('#')

ssh.sendline('ls /home')
ssh.expect('#')

Python-取系統時間

import sys
import time

time_str = time.strftime("日期：%Y-%m-%d",time.localtime())
print(time_str)

time_str= time.strftime("時間：%H:%M",time.localtime())
print(time_str)

psutil-獲取內存使用情況

import sys
import os
import psutil

memory_convent = 1024 * 1024
mem =psutil.virtual_memory()

print("內存容量為:"+str(mem.total/(memory_convent))+"MB ")
print("已使用內存:"+str(mem.used/(memory_convent))+"MB ")
print("可用內存:"+str(mem.total/(memory_convent)-mem.used/(1024*1024))+"MB ")
print("buffer容量:"+str(mem.buffers/( memory_convent ))+"MB ")
print("cache容量:"+str(mem.cached/(memory_convent))+"MB ")

Python-通過SNMP協議監控CPU
注意：被監控的機器上需要支持snmp協議 yum install -y net-snmp*

import os

def getAllitems(host, oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid + '|grep Raw|grep Cpu|grep -v Kernel').read().split(' ')[:-1]
return sn1

def getDate(host):
items = getAllitems(host, '.1.3.6.1.4.1.2021.11')

if name == ' main ':

Python-通過SNMP協議監控系統負載
注意：被監控的機器上需要支持snmp協議 yum install -y net-snmp*

import os
import sys

def getAllitems(host, oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split(' ')
return sn1

def getload(host,loid):
load_oids = Ƈ.3.6.1.4.1.2021.10.1.3.' + str(loid)
return getAllitems(host,load_oids)[0].split(':')[3]

if name == ' main ':

Python-通過SNMP協議監控內存
注意：被監控的機器上需要支持snmp協議 yum install -y net-snmp*

import os

def getAllitems(host, oid):

def getSwapTotal(host):

def getSwapUsed(host):

def getMemTotal(host):

def getMemUsed(host):

if name == ' main ':

Python-通過SNMP協議監控磁碟
注意：被監控的機器上需要支持snmp協議 yum install -y net-snmp*

import re
import os

def getAllitems(host,oid):

def getDate(source,newitem):

def getRealDate(item1,item2,listname):

def caculateDiskUsedRate(host):

if name == ' main ':

Python-通過SNMP協議監控網卡流量
注意：被監控的機器上需要支持snmp協議 yum install -y net-snmp*

import re
import os

def getAllitems(host,oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split(' ')[:-1]
return sn1

def getDevices(host):
device_mib = getAllitems(host,'RFC1213-MIB::ifDescr')
device_list = []

def getDate(host,oid):
date_mib = getAllitems(host,oid)[1:]
date = []

if name == ' main ':

Python-實現多級菜單

import os
import sys

ps="[None]->"
ip=["192.168.1.1","192.168.1.2","192.168.1.3"]
flage=1

while True:
ps="[None]->"
temp=input(ps)
if (temp=="test"):
print("test page !!!!")
elif(temp=="user"):
while (flage == 1):
ps="[User]->"
temp1=input(ps)
if(temp1 =="exit"):
flage=0
break
elif(temp1=="show"):
for i in range(len(ip)):
print(i)

Python實現一個沒用的東西

import sys

ps="[root@localhost]# "
ip=["192.168.1.1","192.168.1.2","192.168.1.3"]

while True:
temp=input(ps)
temp1=temp.split()

檢查各個進程讀寫的磁碟IO

import sys
import os
import time
import signal
import re

class DiskIO:
def init (self, pname=None, pid=None, reads=0, writes=0):
self.pname = pname
self.pid = pid
self.reads = 0
self.writes = 0

def main():
argc = len(sys.argv)
if argc != 1:
print ("usage: please run this script like [./lyshark.py]")
sys.exit(0)
if os.getuid() != 0:
print ("Error: This script must be run as root")
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
os.system('echo 1 > /proc/sys/vm/block_mp')
print ("TASK PID READ WRITE")
while True:
os.system('dmesg -c > /tmp/diskio.log')
l = []
f = open('/tmp/diskio.log', 'r')
line = f.readline()
while line:
m = re.match(
'^(S+)(d+)(d+): (READ|WRITE) block (d+) on (S+)', line)
if m != None:
if not l:
l.append(DiskIO(m.group(1), m.group(2)))
line = f.readline()
continue
found = False
for item in l:
if item.pid == m.group(2):
found = True
if m.group(3) == "READ":
item.reads = item.reads + 1
elif m.group(3) == "WRITE":
item.writes = item.writes + 1
if not found:
l.append(DiskIO(m.group(1), m.group(2)))
line = f.readline()
time.sleep(1)
for item in l:
print ("%-10s %10s %10d %10d" %
(item.pname, item.pid, item.reads, item.writes))
def signal_handler(signal, frame):
os.system('echo 0 > /proc/sys/vm/block_mp')
sys.exit(0)

if name ==" main ":
main()

利用Pexpect實現自動非交互登陸linux

import pexpect
import sys

ssh = pexpect.spawn('ssh [email protected]')
fout = file('sshlog.log', 'w')
ssh.logfile = fout

ssh.expect("[email protected]'s password:")

ssh.sendline("密碼")

ssh.expect('#')
ssh.sendline('ls /home')
ssh.expect('#')

利用psutil模塊獲取系統的各種統計信息

import sys
import psutil
import time
import os

time_str = time.strftime( "%Y-%m-%d", time.localtime( ) )
file_name = "./" + time_str + ".log"

if os.path.exists ( file_name ) == False :
os.mknod( file_name )
handle = open ( file_name , "w" )
else :
handle = open ( file_name , "a" )

if len( sys.argv ) == 1 :
print_type = 1
else :
print_type = 2

def isset ( list_arr , name ) :
if name in list_arr :
return True
else :
return False

print_str = "";

if ( print_type == 1 ) or isset( sys.argv,"mem" ) :
memory_convent = 1024 * 1024
mem = psutil.virtual_memory()
print_str += " 內存狀態如下: "
print_str = print_str + " 系統的內存容量為: "+str( mem.total/( memory_convent ) ) + " MB "
print_str = print_str + " 系統的內存以使用容量為: "+str( mem.used/( memory_convent ) ) + " MB "
print_str = print_str + " 系統可用的內存容量為: "+str( mem.total/( memory_convent ) - mem.used/( 1024*1024 )) + "MB "
print_str = print_str + " 內存的buffer容量為: "+str( mem.buffers/( memory_convent ) ) + " MB "
print_str = print_str + " 內存的cache容量為:" +str( mem.cached/( memory_convent ) ) + " MB "

if ( print_type == 1 ) or isset( sys.argv,"cpu" ) :
print_str += " CPU狀態如下: "
cpu_status = psutil.cpu_times()
print_str = print_str + " user = " + str( cpu_status.user ) + " "
print_str = print_str + " nice = " + str( cpu_status.nice ) + " "
print_str = print_str + " system = " + str( cpu_status.system ) + " "
print_str = print_str + " idle = " + str ( cpu_status.idle ) + " "
print_str = print_str + " iowait = " + str ( cpu_status.iowait ) + " "
print_str = print_str + " irq = " + str( cpu_status.irq ) + " "
print_str = print_str + " softirq = " + str ( cpu_status.softirq ) + " "
print_str = print_str + " steal = " + str ( cpu_status.steal ) + " "
print_str = print_str + " guest = " + str ( cpu_status.guest ) + " "

if ( print_type == 1 ) or isset ( sys.argv,"disk" ) :
print_str += " 硬碟信息如下: "
disk_status = psutil.disk_partitions()
for item in disk_status :
print_str = print_str + " "+ str( item ) + " "

if ( print_type == 1 ) or isset ( sys.argv,"user" ) :
print_str += " 登錄用戶信息如下: "
user_status = psutil.users()
for item in user_status :
print_str = print_str + " "+ str( item ) + " "

print_str += "--------------------------------------------------------------- "
print ( print_str )
handle.write( print_str )
handle.close()

import psutil

mem = psutil.virtual_memory()
print mem.total,mem.used,mem
print psutil.swap_memory() # 輸出獲取SWAP分區信息

cpu = psutil.cpu_stats()
printcpu.interrupts,cpu.ctx_switches

psutil.cpu_times(percpu=True) # 輸出每個核心的詳細CPU信息
psutil.cpu_times().user # 獲取CPU的單項數據 [用戶態CPU的數據]
psutil.cpu_count() # 獲取CPU邏輯核心數，默認logical=True
psutil.cpu_count(logical=False) # 獲取CPU物理核心數

psutil.disk_partitions() # 列出全部的分區信息
psutil.disk_usage('/') # 顯示出指定的掛載點情況【位元組為單位】
psutil.disk_io_counters() # 磁碟總的IO個數
psutil.disk_io_counters(perdisk=True) # 獲取單個分區IO個數

psutil.net_io_counter() 獲取網路總的IO，默認參數pernic=False
psutil.net_io_counter(pernic=Ture)獲取網路各個網卡的IO

psutil.pids() # 列出所有進程的pid號
p = psutil.Process(2047)
p.name() 列出進程名稱
p.exe() 列出進程bin路徑
p.cwd() 列出進程工作目錄的絕對路徑
p.status()進程當前狀態[sleep等狀態]
p.create_time() 進程創建的時間 [時間戳格式]
p.uids()
p.gids()
p.cputimes() 【進程的CPU時間，包括用戶態、內核態】
p.cpu_affinity() # 顯示CPU親緣關系
p.memory_percent() 進程內存利用率
p.meminfo() 進程的RSS、VMS信息
p.io_counters() 進程IO信息，包括讀寫IO數及位元組數
p.connections() 返回打開進程socket的nametples列表
p.num_threads() 進程打開的線程數

import psutil
from subprocess import PIPE
p =psutil.Popen(["/usr/bin/python" ,"-c","print 'helloworld'"],stdout=PIPE)
p.name()
p.username()
p.communicate()
p.cpu_times()

psutil.users() # 顯示當前登錄的用戶，和Linux的who命令差不多

psutil.boot_time() 結果是個UNIX時間戳，下面我們來轉換它為標准時間格式，如下：
datetime.datetime.fromtimestamp(psutil.boot_time()) # 得出的結果不是str格式，繼續進行轉換 datetime.datetime.fromtimestamp(psutil.boot_time()).strftime('%Y-%m-%d%H:%M:%S')

Python生成一個隨機密碼

import random, string
def GenPassword(length):

if name == ' main ':
print (GenPassword(6))

『肆』 python執行多進程時，如何獲取函數返回的值

共享變數的方法。

『伍』 python多線程對多核的利用

GIL 與 Python 線程的糾葛
GIL 是什麼東西？它對我們的 python 程序會產生什麼樣的影響？我們先來看一個問題。運行下面這段 python 程序，CPU 佔用率是多少？
# 請勿在工作中模仿，危險:)
def dead_loop():
while True:
pass

dead_loop()

答案是什麼呢，佔用 100％ CPU？那是單核！還得是沒有超線程的古董 CPU。在我的雙核 CPU 上，這個死循環只會吃掉我一個核的工作負荷，也就是只佔用 50％ CPU。那如何能讓它在雙核機器上佔用 100％ 的 CPU 呢？答案很容易想到，用兩個線程就行了，線程不正是並發分享 CPU 運算資源的嗎。可惜答案雖然對了，但做起來可沒那麼簡單。下面的程序在主線程之外又起了一個死循環的線程
import threading

def dead_loop():
while True:
pass

# 新起一個死循環線程
t = threading.Thread(target=dead_loop)
t.start()

# 主線程也進入死循環
dead_loop()

t.join()

按道理它應該能做到佔用兩個核的 CPU 資源，可是實際運行情況卻是沒有什麼改變，還是只佔了 50％ CPU 不到。這又是為什麼呢？難道 python 線程不是操作系統的原生線程？打開 system monitor 一探究竟，這個佔了 50% 的 python 進程確實是有兩個線程在跑。那這兩個死循環的線程為何不能占滿雙核 CPU 資源呢？其實幕後的黑手就是 GIL。
GIL 的迷思：痛並快樂著
GIL 的全稱為 Global Interpreter Lock ，意即全局解釋器鎖。在 Python 語言的主流實現 CPython 中，GIL 是一個貨真價實的全局線程鎖，在解釋器解釋執行任何 Python 代碼時，都需要先獲得這把鎖才行，在遇到 I/O 操作時會釋放這把鎖。如果是純計算的程序，沒有 I/O 操作，解釋器會每隔 100 次操作就釋放這把鎖，讓別的線程有機會執行（這個次數可以通過sys.setcheckinterval 來調整）。所以雖然 CPython 的線程庫直接封裝操作系統的原生線程，但 CPython 進程做為一個整體，同一時間只會有一個獲得了 GIL 的線程在跑，其它的線程都處於等待狀態等著 GIL 的釋放。這也就解釋了我們上面的實驗結果：雖然有兩個死循環的線程，而且有兩個物理 CPU 內核，但因為 GIL 的限制，兩個線程只是做著分時切換，總的 CPU 佔用率還略低於 50％。
看起來 python 很不給力啊。GIL 直接導致 CPython 不能利用物理多核的性能加速運算。那為什麼會有這樣的設計呢？我猜想應該還是歷史遺留問題。多核 CPU 在 1990 年代還屬於類科幻，Guido van Rossum 在創造 python 的時候，也想不到他的語言有一天會被用到很可能 1000＋ 個核的 CPU 上面，一個全局鎖搞定多線程安全在那個時代應該是最簡單經濟的設計了。簡單而又能滿足需求，那就是合適的設計（對設計來說，應該只有合適與否，而沒有好與不好）。怪只怪硬體的發展實在太快了，摩爾定律給軟體業的紅利這么快就要到頭了。短短 20 年不到，代碼工人就不能指望僅僅靠升級 CPU 就能讓老軟體跑的更快了。在多核時代，編程的免費午餐沒有了。如果程序不能用並發擠干每個核的運算性能，那就意謂著會被淘汰。對軟體如此，對語言也是一樣。那 Python 的對策呢？
Python 的應對很簡單，以不變應萬變。在最新的 python 3 中依然有 GIL。之所以不去掉，原因嘛，不外以下幾點：
欲練神功，揮刀自宮：
CPython 的 GIL 本意是用來保護所有全局的解釋器和環境狀態變數的。如果去掉 GIL，就需要多個更細粒度的鎖對解釋器的眾多全局狀態進行保護。或者採用 Lock-Free 演算法。無論哪一種，要做到多線程安全都會比單使用 GIL 一個鎖要難的多。而且改動的對象還是有 20 年歷史的 CPython 代碼樹，更不論有這么多第三方的擴展也在依賴 GIL。對 Python 社區來說，這不異於揮刀自宮，重新來過。
就算自宮，也未必成功：
有位牛人曾經做了一個驗證用的 CPython，將 GIL 去掉，加入了更多的細粒度鎖。但是經過實際的測試，對單線程程序來說，這個版本有很大的性能下降，只有在利用的物理 CPU 超過一定數目後，才會比 GIL 版本的性能好。這也難怪。單線程本來就不需要什麼鎖。單就鎖管理本身來說，鎖 GIL 這個粗粒度的鎖肯定比管理眾多細粒度的鎖要快的多。而現在絕大部分的 python 程序都是單線程的。再者，從需求來說，使用 python 絕不是因為看中它的運算性能。就算能利用多核，它的性能也不可能和 C/C++ 比肩。費了大力氣把 GIL 拿掉，反而讓大部分的程序都變慢了，這不是南轅北轍嗎。
難道 Python 這么優秀的語言真的僅僅因為改動困難和意義不大就放棄多核時代了嗎？其實，不做改動最最重要的原因還在於：不用自宮，也一樣能成功！
其它神功
那除了切掉 GIL 外，果然還有方法讓 Python 在多核時代活的滋潤？讓我們回到本文最初的那個問題：如何能讓這個死循環的 Python 腳本在雙核機器上佔用 100％ 的 CPU？其實最簡單的答案應該是：運行兩個 python 死循環的程序！也就是說，用兩個分別占滿一個 CPU 內核的 python 進程來做到。確實，多進程也是利用多個 CPU 的好方法。只是進程間內存地址空間獨立，互相協同通信要比多線程麻煩很多。有感於此，Python 在 2.6 里新引入了 multiprocessing這個多進程標准庫，讓多進程的 python 程序編寫簡化到類似多線程的程度，大大減輕了 GIL 帶來的不能利用多核的尷尬。
這還只是一個方法，如果不想用多進程這樣重量級的解決方案，還有個更徹底的方案，放棄 Python，改用 C/C++。當然，你也不用做的這么絕，只需要把關鍵部分用 C/C++ 寫成 Python 擴展，其它部分還是用 Python 來寫，讓 Python 的歸 Python，C 的歸 C。一般計算密集性的程序都會用 C 代碼編寫並通過擴展的方式集成到 Python 腳本里（如 NumPy 模塊）。在擴展里就完全可以用 C 創建原生線程，而且不用鎖 GIL，充分利用 CPU 的計算資源了。不過，寫 Python 擴展總是讓人覺得很復雜。好在 Python 還有另一種與 C 模塊進行互通的機制 : ctypes
利用 ctypes 繞過 GIL
ctypes 與 Python 擴展不同，它可以讓 Python 直接調用任意的 C 動態庫的導出函數。你所要做的只是用 ctypes 寫些 python 代碼即可。最酷的是，ctypes 會在調用 C 函數前釋放 GIL。所以，我們可以通過 ctypes 和 C 動態庫來讓 python 充分利用物理內核的計算能力。讓我們來實際驗證一下，這次我們用 C 寫一個死循環函數
extern"C"
{
void DeadLoop()
{
while (true);
}
}

用上面的 C 代碼編譯生成動態庫 libdead_loop.so （Windows 上是 dead_loop.dll）
，接著就要利用 ctypes 來在 python 里 load 這個動態庫，分別在主線程和新建線程里調用其中的 DeadLoop
from ctypes import *
from threading import Thread

lib = cdll.LoadLibrary("libdead_loop.so")
t = Thread(target=lib.DeadLoop)
t.start()

lib.DeadLoop()

這回再看看 system monitor，Python 解釋器進程有兩個線程在跑，而且雙核 CPU 全被占滿了，ctypes 確實很給力！需要提醒的是，GIL 是被 ctypes 在調用 C 函數前釋放的。但是 Python 解釋器還是會在執行任意一段 Python 代碼時鎖 GIL 的。如果你使用 Python 的代碼做為 C 函數的 callback，那麼只要 Python 的 callback 方法被執行時，GIL 還是會跳出來的。比如下面的例子：
extern"C"
{
typedef void Callback();
void Call(Callback* callback)
{
callback();
}
}

from ctypes import *
from threading import Thread

def dead_loop():
while True:
pass

lib = cdll.LoadLibrary("libcall.so")
Callback = CFUNCTYPE(None)
callback = Callback(dead_loop)

t = Thread(target=lib.Call, args=(callback,))
t.start()

lib.Call(callback)

注意這里與上個例子的不同之處，這次的死循環是發生在 Python 代碼里 (DeadLoop 函數) 而 C 代碼只是負責去調用這個 callback 而已。運行這個例子，你會發現 CPU 佔用率還是只有 50％ 不到。GIL 又起作用了。
其實，從上面的例子，我們還能看出 ctypes 的一個應用，那就是用 Python 寫自動化測試用例，通過 ctypes 直接調用 C 模塊的介面來對這個模塊進行黑盒測試，哪怕是有關該模塊 C 介面的多線程安全方面的測試，ctypes 也一樣能做到。
結語
雖然 CPython 的線程庫封裝了操作系統的原生線程，但卻因為 GIL 的存在導致多線程不能利用多個 CPU 內核的計算能力。好在現在 Python 有了易經筋（multiprocessing）, 吸星大法（C 語言擴展機制）和獨孤九劍（ctypes），足以應付多核時代的挑戰，GIL 切還是不切已經不重要了，不是嗎。

『陸』 如何使用python腳本實現對windows系統監控

示例：

#!/usr/bin/envpython
#encoding:utf-8

"""
MonitorLog.py

Usage:MonitorLog.py...
Monitorthelogfile

-flogfile
-hhelpinfo

pythonMonitorLog.py-fC:monitor.log

Createdbyzhouboon2011-08-29.
"""

importsys
importos
importgetopt
importsubprocess
importtime
importcodecs
importwinsound

ABSPATH=os.path.dirname(os.path.abspath(__file__))
MONITERCONF='moniter_keyword.txt'#utf8file

defmain():
try:
opts,args=getopt.getopt(sys.argv[1:],'hf:')
exceptgetopt.GetoptError,err:
printstr(err)
print__doc__
return1

path=''
fork,vinopts:
ifk=='-f':
path=v
elifk=='-h':
print__doc__
return0

ifnot(pathandos.path.exists(path)):
print'Invalidpath:%s'%path
print__doc__
return2

#命令行元組
cmd=('tail','-f',path)
print''.join(cmd)
output=subprocess.Popen(cmd,stdout=subprocess.PIPE)

keywordMap={}
#載入監控的關鍵字信息
withcodecs.open(os.path.join(ABSPATH,MONITERCONF),'r','utf8')asf:
lines=f.readlines()
forlineinlines:
line=line.strip()
ifnotline:
continue
keyword,wav=line.strip().split(':')
keywordMap[keyword]=wav

whileTrue:
line=output.stdout.readline()
#processcode,得到輸出信息後的處理代碼
ifnotline:
time.sleep(0.01)
continue
line=line.strip().decode('utf8')
printline
forkeywordinkeywordMap:
ifline.find(keyword)>-1:
winsound.PlaySound(keywordMap[keyword],
winsound.SND_NODEFAULT)
#time.sleep(0.01)
return0

if__name__=='__main__':
sys.exit(main())