Github官方仓库：https://github.com/zkbhj/KBTV

• 频道丰富，有超过1500+的直播频道
• 频道质量高，大家常看的央视、卫视、港澳台和地方等频道基本上都是1080P的
• 完全没有任何广告，也没有一个购物台
• 不需要关注什么公众号，不会打扰用户
• 一键安装，操作简单，老人都会用，我就是给我父母搞了一个，在家看电视特方便

./configure --prefix=/usr/local/php8.1 --with-config-file-path=/usr/local/php8.1/etc --with-curl --with-freetype --enable-gd --with-jpeg --with-gettext --with-kerberos --with-libdir=lib64 --with-libxml --with-mysqli --with-openssl --with-pdo-mysql --with-pdo-sqlite --with-pear --enable-sockets --with-mhash --with-ldap-sasl --with-xsl --with-zlib -with-bz2 --with-iconv --enable-fpm --enable-pdo --enable-bcmath  --enable-mbregex --enable-mbstring --enable-opcache --enable-pcntl --enable-soap --enable-sockets --enable-sysvsem --enable-xml --enable-sysvsem --enable-cli --enable-opcache --enable-intl --enable-calendar --enable-static --enable-mysqlnd

configure: error: iconv does not support errno

export LDFLAGS="$LDFLAGS -liconv"

2022/12/08 13:15:51 [error] 31547#0: *29582 FastCGI sent in stderr: "Primary script unknown" while reading response header from upstream, client: 119.116.237.75, server: web.*.com, request: "GET /site/user-agreement HTTP/2.0", upstream: "fastcgi://127.0.0.1:9000", host: "web*.*com"

if (!-e $request_filename){

   rewrite ^/(.*) /index.php last;

}

location / {

    fastcgi_pass   127.0.0.1:9000;

    if (!-e $request_filename){

       rewrite ^/(.*) /index.php last;

    }

    fastcgi_index  index.php;

    fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;

    include        fastcgi_params;

}

Access to Font at “xxx” from origin “xxx” has been by CORS plicy:

No ‘Access-Control-Allow-Origin’header is present on the requested resource. 

Origin “xxx” is therefore not allowed access.

location ~* .(eot|ttf|woff|swoff2|svg|otf)$ {

  add_header Access-Control-Allow-Origin [url]http://www.zkbhj.com;[/url]  //只允许单域名或者 ‘*' 。不推荐 ‘*' ，会导致安全问题

  add_header Access-Control-Allow-Headers X-Requested-With;

  add_header Access-Control-Allow-Methods GET,POST,OPTIONS;

}

• 红包金额拆分是指将指定金额拆分为指定数目红包的过程，用来确定每个红包的金额数；
• 抢红包是用户抢红包的这个操作，典型的高并发场景，需要系统扛流量且避免红包超发的情况；
• 打款就是将抢到的红包通过微信/银行打款到用户钱包的过程（真正把红包的钱拿到手了），因为要对接三方支付系统是整个系统比较耗时的操作，一般通过异步任务来实现；

m=rand(1,floor(M/N∗2))

for ($i = 0; $i < $N - 1; $i++) {

    $max = (int)floor($M / ($N - $i)) * 2;

    $m[$i] = $max ? mt_rand(1, $max) : 0;

    $M -= $m[$i];

}



$m = $M;

-- 领取人的openid为xxxxxxxxxxx

local openid = 'xxxxxxxxxxx'

local isDraw = redis.call('HEXISTS', 'red::draw', openid)

-- 已经领取

if isDraw ~= 0 then

    return true

end

-- 领取太多次了

local times = redis.call('INCR', 'red::draw_count:u:'..openid)

if times and tonumber(times) > 9 then

    return 0

end



local number = redis.call('RPOP', 'red::list')

-- 没有红包

if not number then

    return {}

end

-- 领取人昵称为Fhb,头像为https://xxxxxxx

local red = {money=number,name='Fhb',pic='https://xxxxxxx'}

-- 领取记录

redis.call('HSET', 'red::draw', openid, cjson.encode(red))

-- 处理队列

red['openid'] = openid

redis.call('RPUSH', 'red::task', cjson.encode(red))



return true

需要注意 Lua 脚本执行过程并不是事务的，脚本中的操作命令在执行时是有先后顺序的，当某个操作执行失败时不会回滚已经执行成功的操作。

$maxTask = 1000;

$sleepTime = 1000;



while (true) {

    while ($red = RedLogic::getTask()) {

        RedLogic::doTask($red);

        //处理多少个任务主动退出

        $maxTask--;

        if ($maxTask < 0) {

            return EXIT_CODE_NORMAL;

        }

    }

    //等待任务

    usleep($sleepTime);

}

这里使用 LPOP 命令获取任务，所以使用了 while 结构，并且无任务时需要等待，可以用阻塞命令 BLPOP 来改进。

-What time is it?

-It's 7 o'clock.

It's 7 of the clock.

深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。

如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值）
如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值）

package main



import (

   "fmt"

)



// 定义一个Robot结构体

type Robot struct {

   Name  string

   Color string

   Model string

}



func main() {

   fmt.Println("深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。")

   robot1 := Robot{

      Name:  "小白-X型-V1.0",

      Color: "白色",

      Model: "小型",

   }

   robot2 := robot1

   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)



   fmt.Println("修改Robot1的Name属性值")

   robot1.Name = "小白-X型-V1.1"



   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)



}

深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。

Robot 1：{小白-X型-V1.0 白色 小型}      内存地址：0xc000072330

Robot 2：{小白-X型-V1.0 白色 小型}      内存地址：0xc000072360

修改Robot1的Name属性值

Robot 1：{小白-X型-V1.1 白色 小型}      内存地址：0xc000072330

Robot 2：{小白-X型-V1.0 白色 小型}      内存地址：0xc000072360

package main



import (

   "fmt"

)



// 定义一个Robot结构体

type Robot struct {

   Name  string

   Color string

   Model string

}



func main() {



   fmt.Println("浅拷贝 使用new方式")

   //new方式返回的是一个指针，是引用类型，所以会触发浅拷贝

   robot1 := new(Robot)

   robot1.Name = "小白-X型-V1.0"

   robot1.Color = "白色"

   robot1.Model = "小型"



   robot2 := robot1

   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)



   fmt.Println("在这里面修改Robot1的Name和Color属性")

   robot1.Name = "小蓝-X型-V1.2"

   robot1.Color = "蓝色"



   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)

}

浅拷贝 使用new方式

Robot 1：&{小白-X型-V1.0 白色 小型}     内存地址：0xc000068330

Robot 2：&{小白-X型-V1.0 白色 小型}     内存地址：0xc000068330

在这里面修改Robot1的Name和Color属性

Robot 1：&{小黑-X型-V1.2 黑色 小型}     内存地址：0xc000068330

Robot 2：&{小黑-X型-V1.2 黑色 小型}     内存地址：0xc000068330

package main



import (

   "fmt"

)



// 定义一个Robot结构体

type Robot struct {

   Name  string

   Color string

   Model string

}



func main() {



   fmt.Println("浅拷贝 内容和内存地址一样，改变其中一个对象的值时，另一个同时变化。")

   robot1 := Robot{

      Name:  "小白-X型-V1.0",

      Color: "白色",

      Model: "小型",

   }

   robot2 := &robot1

   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)



   fmt.Println("在这里面修改Robot1的Name和Color属性")

   robot1.Name = "小黑-X型-V1.1"

   robot1.Color = "黑色"



   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)

   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)



}

• RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务
• 本地过程调用：如果需要将本地student对象的age+1，可以实现一个addAge()方法，将student对象传入，对年龄进行更新之后返回即可，本地方法调用的函数体通过函数指针来指定。
• 远程过程调用：上述操作的过程中，如果addAge()这个方法在服务端，执行函数的函数体在远程机器上，如何告诉机器需要调用这个方法呢？

// Client端 

//    Student student = Call(ServerAddr, addAge, student)

1. 将这个调用映射为Call ID。

2. 将Call ID，student（params）序列化，以二进制形式打包

3. 把2中得到的数据包发送给ServerAddr，这需要使用网络传输层

4. 等待服务器返回结果

5. 如果服务器调用成功，那么就将结果反序列化，并赋给student，年龄更新



// Server端

1. 在本地维护一个Call ID到函数指针的映射call_id_map，可以用Map<String, Method> callIdMap

2. 等待服务端请求

3. 得到一个请求后，将其数据包反序列化，得到Call ID

4. 通过在callIdMap中查找，得到相应的函数指针

5. 将student（params）反序列化后，在本地调用addAge()函数，得到结果

6. 将student结果序列化后通过网络返回给Client

• REST通常以业务为导向，将业务对象上执行的操作映射到HTTP动词，格式非常简单，可以使用浏览器进行扩展和传输，通过JSON数据完成客户端和服务端之间的消息通信，直接支持请求/响应方式的通信。不需要中间的代理，简化了系统的架构，不同系统之间只需要对JSON进行解析和序列化即可完成数据的传递。
• 但是REST也存在一些弊端，比如只支持请求/响应这种单一的通信方式，对象和字符串之间的序列化操作也会影响消息传递速度，客户端需要通过服务发现的方式，知道服务实例的位置，在单个请求获取多个资源时存在着挑战，而且有时候很难将所有的动作都映射到HTTP动词。
• 正是因为REST面临一些问题，因此可以采用gRPC作为一种替代方案，gRPC 是一种基于二进制流的消息协议，可以采用基于Protocol Buffer的IDL定义grpc API,这是Google公司用于序列化结构化数据提供的一套语言中立的序列化机制，客户端和服务端使用HTTP/2以Protocol Buffer格式交换二进制消息。
• gRPC的优势是，设计复杂更新操作的API非常简单，具有高效紧凑的进程通信机制，在交换大量消息时效率高，远程过程调用和消息传递时可以采用双向的流式消息方式，同时客户端和服务端支持多种语言编写，互操作性强；不过gRPC的缺点是不方便与JavaScript集成，某些防火墙不支持该协议。
• 注册中心：当项目中有很多服务时，可以把所有的服务在启动的时候注册到一个注册中心里面，用于维护服务和服务器之间的列表，当注册中心接收到客户端请求时，去找到该服务是否远程可以调用，如果可以调用需要提供服务地址返回给客户端，客户端根据返回的地址和端口，去调用远程服务端的方法，执行完成之后将结果返回给客户端。这样在服务端加新功能的时候，客户端不需要直接感知服务端的方法，服务端将更新之后的结果在注册中心注册即可，而且当修改了服务端某些方法的时候，或者服务降级服务多机部署想实现负载均衡的时候，我们只需要更新注册中心的服务群即可。