协同程序
36、协同程序(coroutine)
4种状态:挂起(suspended)、运行(running)、死亡(dead)、正常(normal)
创建(挂起状态):
local co = coroutine.create(
function()
print("coroutine")
end)
启动或再次启动协程(状态由挂起改为运行):
coroutine.resume(co)
coroutine在创建的时候不会自动执行。
检查协程的状态:
coroutine.status(co)
协程在运行完之后,就处于死亡状态,再也无法返回。
使用yield:
local co = coroutine.create(
function()
for i=1,10 do
print(i)
coroutine.yield() --运行到这里让该协程挂起,之后通过调用coroutine.resume恢复它的运行
end
end
)
coroutine.resume(co) --1
coroutine.resume(co) --2
coroutine.resume(co) --3
coroutine.resume(co) --4
coroutine.resume(co) --5
当一个协程 A 唤醒另一个协程 B ,协程 A 就处于一个特殊状态,称为“正常状态”。
local co = coroutine.create(
function(a, b)
print("the first resume params: ", a, b); --在第一次调用resume,传递的额外参数都将视为协同程序主函数的参数;
print("resume params", coroutine.yield("yield return params")) --而yield返回值就是对应resume传入的参数
return "function return" --当一个协同程序结束时,主函数返回值都将作为resume的返回值。
end
)
print(coroutine.resume(co, 1, 2)) --调用resume后返回的内容,第一个值为true则表示没有错误,后面所有值都是对应yield传入的值
print(coroutine.resume(co, 3, 4, 5))
--[[
输出:
the first resume params: 1 2
true yield return params
resume params 3 4 5
true function return
]]
36、协程应用于生产者消费者模式(最好把代码运行一下,再去理解)
function receive(prod)
local status, value = coroutine.resume(prod)
return value
end
function send(x)
coroutine.yield(x)
end
function producer()
return coroutine.create(
function()
while true do
local x = io.read()
send(x)
end
end
)
end
function filter(prod)
return coroutine.create(
function()
for line = 1, math.huge do
local x = receive(prod)
x = string.format("%5d %s", line, x)
send(x)
end
end
)
end
function consumer(prod)
while true do
local x = receive(prod)
io.write(x, "\n")
end
end
p = producer()
f = filter(p)
consumer(f)
37、非抢先式多线程(协程):当一个协程运行时,无法从外部停止,只有协程显示的挂起(yield),才会停止。
常用数据结构
38、数组:以数字作为key的table,在lua中习惯用 1 作为数组起始,长度可变
a = {}
for i =1,10 do
a[i] = 0
end
print(#a) --计算数组长度
--直接创建并初始化数组
a = {7, 6, 5, 5, 7, 8, 9, 0, 0, 5, 3}
39、多维数组,可以用类似其它语言的方式表示多维,也可以利用一维数组表示。用稀疏矩阵表示一个图,table本身就是稀疏的,可以直接表示浪费内存。
mt = {}
for i=1,10 do
mt[i] = {}
for j=1,10 do
mt[i][j] = 0
end
end
遍历“稀疏矩阵”需要注意:一般使用pairs且只遍历那些非nil的元素。
pairs 和 ipairs 的区别:pairs 可以遍历表中所有的key,而ipairs 只能遍历到表中出现的一个不是整数的key
当然还有链表、队列、树、图等数据结构,这就不详细写了,这些东西和在其它语言里面是一样的
40、字符串连接:先把每个字符串存到一个数组里面,然后用table.concat连接,比用(..)连接更快更省
local a = {"A", "b", "C", "d", "E"}
local s = table.concat(a)
数据持久化
41、数据文件(读取):lua常常被用来做数据存取,在lua中,所谓的数据文件就是按一定格式定义的lua文件,把该“数据文件”加载进内存,就可以直接用lua代码解析了。
local count = 0
function Entry(b)
count = count + 1
print("load data call : "..b[1])
end
--dofile("data")
--data文件中就写如下的代码,这里为了简便,就直接把数据写在这里了。
Entry{--注意数据文件里面的Entry必须提前定义,其实数据文件里面的Entry在调用一个名叫Entry的函数
"A", "B", "C", "D", "E"
}
Entry{
"f", "g", "h", "i", "j"
}
print("number of entries : "..count)
42、数据持久化
保存无“环”形table:
function serialize(o)
if type(o) == "number" then
io.write(0)
elseif type(o) == "string" then
io.write(string.format("%q", o))
elseif type(o) == "table" then
io.write("{\n")
for k,v in pairs(o) do
io.write(" [")
serialize(k);
io.write("] = ")
serialize(v)
io.write(", \n")
end
io.write("}\n")
else
--其它情况
error("can not serialize a"..type(o))
end
end
serialize({a = 'A', b = 'Q', c = '1'})
保存有“环”形table:
43、元表:就是普通一个table,可以设置为其他表的元表,元表中可定义实现一系列的元方法
t = {}
t1 = {x = "a"}
setmetatable(t, t1) --把 t1 设置为 t 的元表
print(getmetatable(t)) --获得 t 的元表
44、元方法:定义于元表中的那些重载的方法
算术类元方法(__add(加法),__mul(乘法),__sub(减法),__div(除法),__unm(相反数),__mod(取模),__pow(幂)):
local t = {}
t.__add = function(a, b) --定义加法的元方法
return a["value"] + b["value"]
end
local obj1 = {value = 1}
setmetatable(obj1, t) --
local obj2 = {value = 2}
--setmetatable(obj1, t)
print(obj1 + obj2) --加法的时候,会检查它们其中任意一个的元表,只要有名叫__add的元方法,就会调用它定义的加法运算
关系类元方法(__eq(等于)、__lt(小于)、__le(等于)):
字符串输出元方法(__tostring):
local m = {}
m.__tostring = function()
return "meta function"
end
local a = {}
setmetatable(a, m)
print(a)
保护元表:使用用户既不能看也不能修改集合的元表,定义字段 __metatable
local m = {}
m.__metatable = "not your business" --保护元表
local a = {}
setmetatable(a, m)
print(getmetatable(a)) --not your business
setmetatable(a, m) --cannot change protected metatable
table访问的元方法:
__index元方法:当访问一个table中不存在的字段时,解释器会去查找元表中名叫__index的元方法,如果没有该方法,返回nil,否则由这个元方法提供结果。
local m = {}
m.__index = function()
return "index nil"
end
local a = {}
setmetatable(a, m)
print(a[1]) --index nil
__newindex元方法:当对一个table中不存在的索引赋值时,解释器就会查找__newindex元方法,如果元表中有该元方法,就调用它而不执行赋值。