# 例程1 创建一个线程，并启动该线程
def ThreadFun() #写线程函数，在线程里循环打印100行
{
for i in range(0,100,1)
{
print("% %\n","thread",i)
}
}
thread = THREAD() #定义一个线程变量
# 创建线程，并将线程数据写入thread线程变量
thread = thread.CreateThread(ThreadFun) #默认新创建的线程处于悬挂状态，不会执行
thread.start() #线程的start()方法，将启动当前thread线程运行
# 主线程程序
for i in range(0,100,1)
{
print("% %\n","main",i)
}
print("\n")
print("%\n","主线程执行结束")
# 例程2 线程同步。创建一个线程，让主线程等待子线程执行结束后
# 很多时候，我们希望在主线程中，等待子线程完成任务后，在继续主线程的
# 任务，这就需要线程同步——thread.join()线程等待
def ThreadFun() #写线程函数，在线程里循环打印100行
{
for i in range(0,100,1)
{
print("% %\n","thread",i)
}
}
thread = THREAD() #定义一个线程变量
thread = thread.CreateThread(ThreadFun) #创建线程，新线程处于悬挂状态
thread.start() #启动当前thread子线程运行
thread.join()
# 上句的目的是要求主线程在此处等待，等到子线程执行完毕，再继续主线程
# 有了线程同步join()，就能保证只有子线程100行打印完后，才会继续主线程
# 运行，即，打印"主线程执行结束"
# 但是，多线程的第一个时间片总是分配给主线程，因此，thread.join()只能在
# 第一个时间片结束后，才生效。
# 如果主线程占时很短，主线程结束，并不影响子线程执行。
for i in range(0,100,1)
{
print("% %\n","main after join()",i)
}
print("\n")
print("%\n","主线程执行结束")
# 例程3 多线程同步
def ThreadFun()
{
for i in range(0,100,1)
{
print("% %\n","thread",i)
}
}
def ThreadFun1()
{
for i in range(0,100,1)
{
print("% %\n","thread111111111",i)
}
}
thread = THREAD()
thread = thread.CreateThread(ThreadFun)
thread1 = THREAD()
thread1 = thread1.CreateThread(ThreadFun1)
thread.start()
thread1.start()
for i in range(0,50,1)
{
print("% %\n","main",i)
}
thread.join()
thread1.join()
for i in range(0,30,1)
{
print("% %\n","main after join()",i)
}
print("\n")
print("%\n","主线程执行结束")
print("\n")
# 例程4 携带参数的子线程
def ThreadFun(x,y) #写线程函数，传递两个参数 x,y
{
for i in range(0,100,1)
{
print("% %\n","thread",x+y) #打印两个参数之和
}
}
thread = THREAD() #定义一个线程变量
# 注意：CreateThread()函数的第一个参数是线程函数名，从第二个参数开
# 始，分别对应线程函数的参数。即CreateThread()比ThreadFun()多一个
# 参数，多出的这个参数（线程函数名ThreadFun）放在最前面的位置。
# 线程函数名作为第一个参数，实参5对应形参x，实参7对应形参y，保证顺序
thread = thread.CreateThread(ThreadFun,5,7) #创建线程，新线程处于悬挂状态
thread.start() #启动当前thread子线程运行
thread.join() #要求主线程等待子线程
for i in range(0,30,1)
{
print("% %\n","main after join()",i)
}
print("\n")
print("%\n","主线程执行结束")
# 运行结果：子线程打印的是实参5+7的值
# 例程5 同一个线程函数，可以创建多个独立运行的线程
def ThreadFun(x) #写线程函数，传递一个参数 x
{
for i in range(0,100,1)
{
print("% %\n","thread",x) #打印两个参数之和
}
}
list = []
# 同一个线程函数ThreadFun，可以创建多个线程，多个线程独立运行
for i in range(0,5,1)
{
thread = THREAD() #定义一个线程变量
thread = thread.CreateThread(ThreadFun,i) #创建线程，新线程处于悬挂状态
list.append(thread)
}
for i in range(0,5,1)
{
thread = list[i]
thread.start() #启动当前thread子线程运行
thread.join() #要求主线程等待子线程
}
# 主线程默认是立即开启的
for i in range(0,200,1)
{
print("% %\n","main after join()",i)
}
print("\n")
print("%\n","主线程执行结束")
print("\n")
# 同一个线程函数可以建立多个独立运行的线程
# 例程6 多个线程共用一个变量的情况下，防写数据冲突
# 多个线程共用一个变量时，一个线程写数据时，为避免冲突可以加锁
# th1.locked()加锁，短时间独占变量，避免冲突
# th1.unlock()解锁。
a = 0 #定义全局变量，多线程共用变量
def ThreadFun() #写线程函数
{
th1 = THREAD() # 要用到线程方法，因此，这里定义一个线程对象th
for j in range(0,200,1)
{
th1.locked()
a = 5
th1.unlock()
print("sub a = % j = %\n",a,j)
}
print("sub结束 a = %\n",a)
}
thread = THREAD()
thread = thread.CreateThread(ThreadFun)
thread.start()
# 主线程开始执行
th2 = THREAD()
for i in range(0,200,1)
{
th2.locked()
a = 20000
th2.unlock()
print("main a = % i = %\n",a,i)
}
print("\n")
print("%\n","主线程执行结束")
# 例程7 获取线程ID
def ThreadFun()
{
for i in range(0,100,1)
{
print("% %\n","thread",i)
}
print("\n")
print("%\n","sub_子线程执行结束")
print("\n")
}
thread = THREAD()
thread = thread.CreateThread(ThreadFun)
thread.start()
#thread.join() #要求主线程等待子线程
# 主线程程序
for i in range(0,150,1)
{
print("% %\n","main after join()",i)
}
thread_ID = thread.get_ID() #若果ID=0，说明是一个空的线程变量，非实线程
print("\n")
print("子线程ID = %\n",thread_ID)
print("\n")
print("%\n","主线程执行结束")
# 例程8 模拟一个定时器溢出信号，人为发生线程切换
# 无输入参数，无返回
# 用途：当主线程或子线程有循环查询状态（“慢动作”）时，如果没有查询到状态变化，
# 可以强制立即切换线程（不是结束线程，保留线程继续查询），避免空转浪费时间；
# 如果查询到状态变化，执行动作完成后，结束线程。
def ThreadFun()
{
th = THREAD()
for i in range(0,20,1)
{
print("% %\n","thread",i)
th.threadchange()
# 每打印一行就切换线程
}
print("\n")
print("%\n","sub_子线程执行结束")
print("\n")
}
thread = THREAD()
thread = thread.CreateThread(ThreadFun)
# 主线程程序
count = 150
#for i in range(0,50,1)
while count
{
print("% %\n","main after join()",count)
count = count - 1
}
thread_ID = thread.get_ID() #若果ID=0，说明是一个空的线程变量，非实线程
print("\n")
print("子线程ID = %\n",thread_ID)
print("\n")
print("%\n","主线程执行结束")
# 例程9 挂起子线程
# 在多线程运行过程中，可以将一个、或多个子线程挂起，还可以重新启动
# thread.suspend()挂线程，thread.start()启动线程。
def ThreadFun() #写线程函数
{
for j in range(0,300,1)
{
a = 5
print("sub a = % j = %\n",a,j)
}
print("\n")
print("sub结束 a = %\n",a)
}
thread = THREAD()
thread = thread.CreateThread(ThreadFun)
time = TIME()
# 主线程开始执行
for i in range(0,200,1)
{
a = 20000
print("main a = % i = %\n",a,i)
if i == 130
{
thread.suspend() #主线程运行到130时，将子线程挂起
}
elif i == 180
{
thread.start() #主线程运行到180时，重启子线程
}
}
print("\n")
print("%\n","主线程执行结束")
