#!/usr/bin/python
#-*-coding:utf-8-*-
import threading
#用于線程執(zhí)行的函數(shù)
def counter(n):
  cnt = 0;
  for i in xrange(n):
    for j in xrange(i):
      cnt += j;
  print cnt;
if __name__ == '__main__':
 #初始化一個線程對象，傳入函數(shù)counter，及其參數(shù)1000
  th = threading.Thread(target=counter, args=(1000,));
 #啟動線程
  th.start();
 #主線程阻塞等待子線程結(jié)束
  th.join();

#!/usr/bin/python
#-*-coding:utf-8-*-
import threading
#可調(diào)用的類
class Callable(object):
  def __init__(self, func, args):
    self.func = func;
    self.args = args;
  def __call__(self):
    apply(self.func, self.args);
#用于線程執(zhí)行的函數(shù)
def counter(n):
  cnt = 0;
  for i in xrange(n):
    for j in xrange(i):
      cnt += j;
  print cnt;
if __name__ == '__main__':
 #初始化一個線程對象，傳入可調(diào)用的Callable對象，并用函數(shù)counter及其參數(shù)1000初始化這個對象
  th = threading.Thread(target=Callable(counter, (1000,)));
 #啟動線程
  th.start();
 #主線程阻塞等待子線程結(jié)束
  th.join();

#!/usr/bin/python
#-*-coding:utf-8-*-
import threading, time, random
def counter():
  cnt = 0;
  for i in xrange(10000):
    for j in xrange(i):
      cnt += j;
class SubThread(threading.Thread):
  def __init__(self, name):
    threading.Thread.__init__(self, name=name);
  def run(self):
    i = 0;
    while i < 4:
      print self.name,'counting...\n';
      counter();
      print self.name,'finish\n';
      i += 1;
if __name__ == '__main__':
  th = SubThread('thread-1');
  th.start();
  th.join();
  print 'all done';

#!/usr/bin/python
#-*-coding:utf-8-*-
import multiprocessing, time
def run():
  i = 0;
  while i<10000:
    print 'running';
    time.sleep(2);
    i += 1;
if __name__ == '__main__':
  p = multiprocessing.Process(target=run);
  p.start();
  #p.join();
  print p.pid;
  print 'master gone';

pool = multiprocessing.Pool(processes=4)
pool.apply_async(func, args...)

#!/usr/bin/python
#-*-coding:utf-8-*-
import multiprocessing, signal,time
def handler(signum, frame):
  print 'signal', signum;
def run():
  signal.signal(signal.SIGTERM, handler);
  signal.signal(signal.SIGINT, handler);
  i = 0;
  while i<10000:
    print 'running';
    time.sleep(2);
    i += 1;
if __name__ == '__main__':
  p = multiprocessing.Process(target=run);
  p.start();
  #p.join();
  print p.pid;
  print 'master gone';

class Master(multiprocessing.Process):
  def __init__(self):
    super(Master,self).__init__();
    signal.signal(signal.SIGTERM, self.handler);   #注冊信號處理函數(shù)
    self.live = 1;
  #信號處理函數(shù)
  def handler(self, signum, frame):
    print 'signal:',signum;
    self.live = 0;
  def run(self):
    print 'PID:',self.pid;
    while self.live:
      print 'living...'
      time.sleep(2);

#!/usr/bin/python
#-*-coding:utf-8-*-
import time, multiprocessing, signal, threading, random, time, Queue
class Master(multiprocessing.Process):
  def __init__(self):
    super(Master,self).__init__();
    signal.signal(signal.SIGTERM, self.handler);
 #這個變量要傳入線程用于控制線程運行，為什么用dict？充分利用線程間共享資源的特點
 #因為可變對象按引用傳遞，標量是傳值的，不信寫成self.live = true試試
    self.live = {'stat':True};
  def handler(self, signum, frame):
    print 'signal:',signum;
    self.live['stat'] = 0;                  #置這個變量為0，通知子線程可以“收工”了
  def run(self):
    print 'PID:',self.pid;
    cond = threading.Condition(threading.Lock());      #創(chuàng)建一個condition對象，用于子線程交互
    q = Queue.Queue();                    #一個隊列
    sender = Sender(cond, self.live, q);           #傳入共享資源
    geter = Geter(cond, self.live, q);
    sender.start();                     #啟動線程
    geter.start();
    signal.pause();                     #主線程睡眠并等待信號
    while threading.activeCount()-1:             #主線程收到信號并被喚醒后，檢查還有多少線程活著（除掉自己）
      time.sleep(2);                    #再睡眠等待，確保子線程都安全的結(jié)束
      print 'checking live', threading.activeCount();
    print 'mater gone';
class Sender(threading.Thread):
  def __init__(self, cond, live, queue):
    super(Sender, self).__init__(name='sender');
    self.cond = cond;
    self.queue = queue;
    self.live = live
  def run(self):
    cond = self.cond;
    while self.live['stat']:                 #檢查這個進程內(nèi)的“全局”變量，為真就繼續(xù)運行
      cond.acquire();                   #獲得鎖，以便控制隊列
      i = random.randint(0,100);
      self.queue.put(i,False);
      if not self.queue.full():
        print 'sender add:',i;
      cond.notify();                    #喚醒等待鎖的其他線程
      cond.release();                   #釋放鎖
      time.sleep(random.randint(1,3));
    print 'sender done'
class Geter(threading.Thread):
  def __init__(self, cond, live, queue):
    super(Geter, self).__init__(name='geter');
    self.cond = cond;
    self.queue = queue;
    self.live = live
  def run(self):
    cond = self.cond;
    while self.live['stat']:
      cond.acquire();
      if not self.queue.empty():
        i = self.queue.get();
        print 'geter get:',i;
      cond.wait(3);
      cond.release();
      time.sleep(random.randint(1,3));
    print 'geter done'
if __name__ == '__main__':
  master = Master();
  master.start();                       #啟動子進程