def main():
file = open("file.txt")
q = Queue()
t = Thread(target=enq, args=(file,q))
t.isDaemon()
t.start()
doSomethingWithData()
class threadedConnection(baseConnection):
def setup(self,config,name="ThreadedConnection"):
super(threadedConnection,self).setup(config,name)
self.thread = Thread(target=self.run,name=name)
self.keep_running = True
def join(self,*args,**kwargs):
self.thread.join(*args,**kwargs)
def run(self):
raise NotImplementedError()
def start(self):
self.thread.start()
return True
def wake(self):
return True
def stop(self,wait=True): # API, runs outside of thread
self.keep_running = False
self.wake()
if wait and not self.thread.isDaemon() and currentThread() != self.thread:
self.join()
return True
class PickleAwareThread (object):
__metaclass__ = ClassInfoMetaclass
def __init__(self, group = None, target = None, name = None, args = (), kwargs = {}):
self.__thread = Thread(group = group, target = self.__run_thread, name = name, args = args, kwargs = kwargs)
self.__group = group
self.__target = target
self.__name = self.__thread.getName()
self.__args = args
self.__kwargs = kwargs
self.__is_daemon = self.__thread.isDaemon()
self.__started = False
self.__stopped = False
def __pickle_data(self, data):
del data[getattrname(self.__clsname, "__thread")]
def __unpickle_data(self, data):
if not self.__started:
self.__thread = Thread(group = self.__group, target = self.__run_thread, name = self.__name, args = self.__args,
kwargs = self.__kwargs)
else:
self.__thread = None
def __getstate__(self):
return pickle_data(self)
def __setstate__(self, data):
unpickle_data(self, data)
def start(self):
if self.__thread:
self.__started = True
self.__thread.start()
else:
assert False, "thread already started"
def __run_thread(self):
self.__started = True
try:
self.run()
finally:
self.__stopped = True
def run(self):
if self.__target:
self.__target(*self.__args, **self.__kwargs)
def join(self, timeout = None):
if self.__thread:
self.__thread.join(timeout)
elif not self.__stopped:
raise ThreadPickledAliveException
def getName(self):
return self.__name
def setName(self, name):
self.__name = name
if self.__thread:
self.__thread.setName(name)
def isAlive(self):
if self.__thread:
return self.__thread.isAlive()
elif self.__stopped:
return False
else:
raise ThreadPickledAliveException
def isDaemon(self):
return self.__is_daemon
def setDaemon(self, daemonic):
assert not self.__started, "cannot set daemon status of active thread"
self.__thread.setDaemon(daemonic)
self.is_daemon = daemonic
#!/usr/bin/env python
# _*_coding:utf-8_*_
from threading import Thread
import time
def foo(arg, v):
for item in range(100):
print item
time.sleep(1)
print 'before'
t1 = Thread(target=foo, args=('test1', 10))
t1.setDaemon(daemonic=True)
t1.start()
t1.join(5)
print '\n---'
print t1.getName()
print t1.isDaemon()
print 'after'
#time.sleep(10) #当主线程退出后，子线程也随着销毁
# daemon屬性
from threading import Thread
from time import sleep
def fun():
sleep(3)
print("daemon 測試")
t = Thread(target=fun)
t.setDaemon(True)
print(t.isDaemon())
t.start()
print("========================")
# daemon属性
import time
from threading import Thread, currentThread
def fun(sec):
print("线程属性测试")
time.sleep(sec)
print("线程结束")
th = Thread(name="th_1", target=fun, args=(3, ))
print("Daemon:", th.isDaemon())
th.daemon = True
print("Daemon:", th.isDaemon())
th.start()
print("thread name:", th.name)
print("alive:", th.is_alive())
print(currentThread().getName())
th.join(4)
print("========主线程结束=========")
from threading import Thread
import time
def fun(arg, sleep_time):
time.sleep(sleep_time)
print(arg)
# 实例化一个线程
t1 = Thread(target=fun, args=('Thread 1', 1))
t2 = Thread(target=fun, args=('Thread 2', 0))
# 修改,查看线程名
t1.setName('th001')
print('thread name: ', t1.getName())
# 查看,并设置 t1 为守护线程 --> 当主线程结束后, 一起结束
print(t1.isDaemon())
t1.setDaemon(True)
print(t1.isDaemon())
# 启动线程
t1.start()
t2.start()
print('finally')
class PickleAwareThread(object):
__metaclass__ = ClassInfoMetaclass
def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
self.__thread = Thread(group=group,
target=self.__run_thread,
name=name,
args=args,
kwargs=kwargs)
self.__group = group
self.__target = target
self.__name = self.__thread.getName()
self.__args = args
self.__kwargs = kwargs
self.__is_daemon = self.__thread.isDaemon()
self.__started = False
self.__stopped = False
def __pickle_data(self, data):
del data[getattrname(self.__clsname, "__thread")]
def __unpickle_data(self, data):
if not self.__started:
self.__thread = Thread(group=self.__group,
target=self.__run_thread,
name=self.__name,
args=self.__args,
kwargs=self.__kwargs)
else:
self.__thread = None
def __getstate__(self):
return pickle_data(self)
def __setstate__(self, data):
unpickle_data(self, data)
def start(self):
if self.__thread:
self.__started = True
self.__thread.start()
else:
assert False, "thread already started"
def __run_thread(self):
self.__started = True
try:
self.run()
finally:
self.__stopped = True
def run(self):
if self.__target:
self.__target(*self.__args, **self.__kwargs)
def join(self, timeout=None):
if self.__thread:
self.__thread.join(timeout)
elif not self.__stopped:
raise ThreadPickledAliveException
def getName(self):
return self.__name
def setName(self, name):
self.__name = name
if self.__thread:
self.__thread.setName(name)
def isAlive(self):
if self.__thread:
return self.__thread.isAlive()
elif self.__stopped:
return False
else:
raise ThreadPickledAliveException
def isDaemon(self):
return self.__is_daemon
def setDaemon(self, daemonic):
assert not self.__started, "cannot set daemon status of active thread"
self.__thread.setDaemon(daemonic)
self.is_daemon = daemonic
def main(ARGS):
# Init variables
latest_mask_img = None
cap_file = None
input_q = queue.Queue(maxsize=1)
output_q = queue.Queue(maxsize=1)
estimator = BodyPixEstimator(ARGS.model, ARGS.stride, ARGS.shrink_factor)
# Open the capture device
cap = cv2.VideoCapture(ARGS.cap_source)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, ARGS.cap_res[0])
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, ARGS.cap_res[1])
if not cap.isOpened():
logger.error("Could not open the specified device.")
return
# Load the background image/video
if ARGS.bg_video:
cap_file = cv2.VideoCapture(ARGS.bg_video)
elif ARGS.bg_url:
v_pafy = pafy.new(ARGS.bg_url)
play = v_pafy.getbestvideo()
cap_file = cv2.VideoCapture(play.url)
bg_img = cv2.imread(ARGS.bg_image)
bg_img = cv2.resize(bg_img, dsize=ARGS.cap_res)
# Start the prediction thread
is_running = Event()
is_running.set()
th = Thread(name="mask_image_generator", target=mask_image_generator,
args=(is_running, estimator, input_q, output_q,))
th.isDaemon = True
th.start()
while True:
ret, frame = cap.read()
if not ret:
logger.warn("cap.read() failed.")
continue
# Flip the image if requested
if ARGS.flip != -1:
frame = cv2.flip(frame, ARGS.flip)
# Pass the image to the generator thread
im_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
if input_q.full():
input_q.get()
input_q.put(im_rgb, block=False)
# Get the mask image if possible
if output_q.qsize() > 0:
latest_mask_img = output_q.get_nowait()
# Load a frame from the background video file
if cap_file:
ret, bg_img = cap_file.read()
if not ret:
cap_file.set(cv2.CAP_PROP_POS_FRAMES, 0)
ret, bg_img = cap_file.read()
bg_img = cv2.resize(bg_img, dsize=ARGS.cap_res)
if latest_mask_img is not None:
# Composite the foreground and background images
mask = latest_mask_img
composed = np.zeros(frame.shape, dtype=frame.dtype)
for i in range(3):
composed[:,:,i] = bg_img[:,:,i] * (1-mask[:,:,i]/255) + frame[:,:,i] * (mask[:,:,i]/255)
# Output the frame
if ARGS.show_only_gui:
cv2.imshow("frame", composed)
else:
sys.stdout.buffer.write(composed.tobytes())
else:
if ARGS.show_only_gui:
cv2.imshow("frame", bg_img)
else:
sys.stdout.buffer.write(bg_img.tobytes())
if cv2.waitKey(1) != -1:
break
is_running.clear()
th.join()
cap.release()
cv2.destroyAllWindows()
Created on 2016年4月25日
@author: zhongqiang
Describe: 多线程的实现方式和相关的方法
'''
from threading import Thread
from time import sleep, ctime, sleep
def myfunction(arg):
for item in range(10):
print item
sleep(1)
print "before"
t1 = Thread(target=myfunction, args=('hello',))
print t1.getName() # Thread-1
print t1.isDaemon() # 默认为false
# t1.setDaemon(True) #设置为setDaemon模式
t1.start()
t1.join(timeout=5)
print "after"
print "Over"
sleep(5)
"""线程属性演示"""
from threading import Thread
from time import sleep
def fun():
sleep(3)
print("线程属性测试")
t = Thread(target=fun)
#主线程退出分支线程也退出
t.setDaemon(True)
t.start()
t.setName("zhangqiang")
print("Name:", t.getName())
print("Alive", t.is_alive())
print('Daemon:', t.isDaemon())
t.join()
json.dump(gpsData, f)
def runC():
sdr.sample_rate = 2.4e6
sdr.center_freq = 900e6
sdr.gain = 40
global run
samples = sdr.read_samples(256*4096)
spectrum[time.time()] = str(samples)
with open('spectrumData', 'w') as g:
json.dump(spectrum, g)
if __name__ == "__main__":
t1 = Thread(target = runA)
t2 = Thread(target = runB)
t3 = Thread(target = runC)
t1.isDaemon()
t2.isDaemon()
t3.isDaemon()
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
# item = make_an_item_available(i)
item = i
queue.put(str(item))
# queue.put(str("exit"))
def consumer(queue):
while True:
item = queue.get()
if item == "exit":
break
# print("Received item in queue fro thread" + item)
queue.task_done()
queue = Queue()
t1 = Thread(target=producer, args=(queue, ))
t2 = Thread(target=consumer, args=(queue, ))
t1.daemon = True
t2.daemon = True
t1.start()
t2.start()
import time
t1.join()
while True:
print(t1.isAlive(), t1.isDaemon())
print(t2.isAlive(), t2.isDaemon(), t2.getName())
# t2.daemon =False
time.sleep(2)
# -*- coding: utf-8 -*-
from threading import Thread
import os
import time
def sleeper(name, seconds):
print 'starting child process with id: ', os.getpid()
print 'parent process:', os.getppid()
print 'sleeping for %s ' % seconds
time.sleep(seconds)
print "%s done sleeping" % name
if __name__ == '__main__':
print "in parent process (id %s)" % os.getpid()
p = Thread(target=sleeper, args=('bob', 5))
print 'daemon?', p.isDaemon()
p.setDaemon(not p.isDaemon())
print 'daemon?', p.isDaemon()
p.start()
print "in parent process after child process start"
print "parent process about to join child process"
p.join()
print "in parent process after child process join"
print "parent process exiting with id ", os.getpid()
print "The parent's parent process:", os.getppid()
print " Global Location: %s" % vehicle.location.global_frame
vehicle.simple_goto(LocationGlobalRelative(myLat,myLon,alt))
time.sleep(3)
print " Global Location: %s" % vehicle.location.global_frame
vehicle.close()
run = False
print("done")
def runB():
global run
while run:
#gpsData[time.time()] = str(vehicle.location.global_frame)
gpsData[datetime.datetime.fromtimestamp(int(time.time())).strftime('%Y-%m-%d %H:%M:%S')] = str(vehicle.location.global_frame)
time.sleep(.1)
with open('gpsTimestamps', 'w') as f:
json.dump(gpsData, f)
if __name__ == "__main__":
t1 = Thread(target = runA)
t2 = Thread(target = runB)
t1.isDaemon()
t2.isDaemon()
t1.start()
t2.start()
t1.join()
t2.join()
from threading import Thread, currentThread
from time import sleep
def fun():
print("当前线程:", currentThread().getName())
sleep(3)
print("线程属性示例")
#创建线程对象
t = Thread(target=fun, name="Tedu")
#设置daemon
t.setDaemon(True)
print("Daemon:", t.isDaemon())
t.start()
#线程名称
t.setName('tarena')
print("name:", t.getName())
print("线程状态:", t.isAlive())
print("线程状态:", t.is_alive())
# t.join()
"""
import os, sys
import time
from threading import Thread
def Foo(arg,arg2):
for i in range(30):
print i
time.sleep(1)
print 'before'
t1 = Thread(target=Foo,args=(1,2,))
t1.setDaemon(True)
t1.start()
t1.join(5) #主线程到达join，直到子线程结束才继续主线程。默认不超时，如果超过5s，超时后主线程不等待
print t1.getName()
#t1.setName('testthread')
print t1.isDaemon() #False 等待子线程完成才结束主线程。True 主线程结束就退出，不等待子线程.是否守护
print t1.isAlive()
print 'after'
print 'after'
print 'after'
print 'after end'
time.sleep(10)
"""
thread_attr.py
线程属性演示
"""
from threading import Thread
from time import sleep
def fun():
sleep(3)
print("进程属性设置")
t = Thread(target=fun,name="AID")
t.setDaemon(True) # 主线程退出分支线程也退出
t.start()
t.setName('Tarena')
print("Name:",t.getName())
print("is alive:",t.is_alive())
print("is daemon:",t.isDaemon())
