python：线程的使用、线程共享全局变量、列表作为参数（全局变量）、避免全局变量被修改

进程是资源分布的单元

线程是进程中真正执行代码的

进程运行起来，会有一个主线程进行运行 

父子线程：相互独立运行，当所有的子线程执行完后，主线程才执行完

下面这个程序就是一个线程

#线程也是python实现多任务的一种方式，thread模块是比较底层的模块
#threading模块是对thread做了一些包装，更方便使用
#多线程的执行
import threading
import time

def sayHello():#多个线程去执行一个函数，完全可以
	print("hello")
	time.sleep(2)

if __name__=="__main__":
	for i in range(5):
		t=threading.Thread(target=sayHello)#同时执行，而不是一个一个执行
		t.start()#创建一个新的线程，去target中执行，这里开启 了5个线程

'''
hello
hello
hello
hello
hello
'''

创建线程的另外一种方式：

import threading
import time

class MyThread(threading.Thread):
	def run(self):
		for i in range(3):
			time.sleep(1)
			msg="I'm" +self.name+'@'+str(i) #name属性中保存的是当前线程的名字
			print(msg)

if __name__=='__main__':
	t=MyThread()#实例化类的对象就可以调用
	t.start()

'''
I'mThread-1@0
I'mThread-1@1
I'mThread-1@2
'''

父子进程和父子线程的执行顺序不一定，由操作系统的调度算法决定

线程共享全局变量，进程不是

import threading
from threading import Thread
import time

thnum=100

class MyThread(threading.Thread):
	def run(self):
		for i in range(3):
			global thnum
			thnum+=100
			time.sleep(1)
			msg="I'm" +self.name+'@'+str(i) #name属性中保存的是当前线程的名字
			print(msg)
			print(thnum)

def test():
	global thnum
	print(thnum)
if __name__=='__main__':
	t=MyThread()
	t.start()

time.sleep(4)#保证第一个线程执行完
thn=Thread(target=test)
thn.start()

'''
I'mThread-1@0
200
I'mThread-1@1
300
I'mThread-1@2
400
400
'''

线程使用全局变量的弊端，一旦设置不好时间，则输出错误的结果

import threading
from threading import Thread
import time

thnum=0

class MyThread(threading.Thread):
	def run(self):
		for i in range(10000):
			global thnum
			thnum+=1	
		print(thnum)

def test():
	global thnum
	for i in range(10000):
		thnum+=1
	print(thnum)
if __name__=='__main__':
	t=MyThread()
	t.start()

time.sleep(4)#保证第一个线程执行完,这样的话运行结果为20000
#但是如果将这句话屏蔽掉的话，就会发现结果不是20000，全局变量的值在其中有交叉，而不是先运行完第一个程序再运行第二个程序
thn=Thread(target=test)
thn.start()

'''
I'mThread-1@0
200
I'mThread-1@1
300
I'mThread-1@2
400
400
'''

列表当做参数传递给线程，会当做全局变量

import threading
from threading import Thread
import time

thnum=[11,22,33,44]

class MyThread(threading.Thread):
	def run(self):
		for i in range(3):
			thnum.append(i)	
		print(thnum)

def test():
	print(thnum)
if __name__=='__main__':
	t=MyThread()
	t.start()

time.sleep(1)#保证第一个线程执行完
thn=Thread(target=test)
thn.start()

'''
[11, 22, 33, 44, 0, 1, 2]
[11, 22, 33, 44, 0, 1, 2]

'''

避免全局变量被修改：

import threading
from threading import Thread
import time

thnum=0
f_flag=0

class MyThread(threading.Thread):
	def run(self):
		for i in range(10000):
			global thnum
			thnum+=1
		global f_flag
		f_flag=1	
		print(thnum)

def test():
	global thnum#下面的f_flag是全局变量，但是这里没有进行修改，所有不用加global
	while True:
	    if f_flag!=0:
	    	for i in range(10000):
	    		thnum+=1
	    	break

	print(thnum)
if __name__=='__main__':
	t=MyThread()
	t.start()

time.sleep(4)#保证第一个线程执行完,这样的话运行结果为20000
#但是如果将这句话屏蔽掉的话，就会发现结果不是20000，全局变量的值在其中有交叉，而不是先运行完第一个程序再运行第二个程序
thn=Thread(target=test)
thn.start()

'''
10000
20000
'''