Gin_Q

售票系统就是一个使用锁的列子！

python 事件锁挺好用

import threading
import time


def fun(event_lock, tips):
    while True:
        event_lock.wait()
        print(tips)
        time.sleep(1)
        


if __name__ == "__main__":
    event_lock = threading.Event()
    event_lock.set()
    t1 = threading.Thread(target = fun, args = (event_lock, "线程 1"), daemon = True)
    t2 = threading.Thread(target = fun, args = (event_lock, "线程 2"), daemon = True)
    
    t1.start()
    t2.start()
    
    input_str = ''
    while True:
        input_str = input("1: 暂定线程 2: 开始线程")
        if input_str == "1":
            event_lock.clear()
        elif input_str == "2":
            event_lock.set()
    t1.join()
复制代码

xczxczxcz

首先 感谢 大家的回复。
一、带锁的危险性
    在异步多线程时，线程量很大时，线程请求频繁时，锁会让你的异步多线程崩溃。几年前一直在测试这个问题，偶看过的大多数线程教程都有问题。只是他们的例子太简单，反映不出问题。理论和实际是有区别的。

二、真正的多线程是就应该不带锁的
    多线程就应该自由不受线程约束。 如10个和尚挑水把水缸装满。一次只一个人倒水，哪怕挑得再快，也和同步没多大区别。若把水缸换成10个水水缸，每个各尚负责一个缸，那立马搞定。
    带了锁的还是划分到队列或者链表等合理些。

三、偶这几年自行摸索的方法
    经过长时间测试，本地也好网络也好，发现运行良好，非常稳定，也许在其他教程上有，只是偶看得太少。
    方法：
   自定义类型封装：占21个字节
   1；所封装的数据在整个数据中的位置， 点4个字节；
   2；所封装的数据在内存所有坑中的索引或内存地址(C++)。  占4个字节；
   3；封装的数据线程完成状态，字符串型 占4个字节；线程执行完，说一声我做完了，
   4；封装的数据执行结果， bool 占1个字节，线程执行完把结果成功与否丟下就走了，
   5；封装数据的统一取消指令， 事件通知， 占4个字节 (类似于群主发一条信息，所有的群成员都马上知悉，并处理这一指令)
   6；封装数据接收结果的内存地址， 占4个字节，线程把处理完的数据的快递地址留下就不管了。
  
   经过这样处理包装每一个数据后，通过线程池进入异步下载，然后就不用管他了，只接收它的信号通知就可以了， 如果是客户端就信号显示在表格中。
   如果想取消下载，只要发个通知，所有线程马上停止(这个偶弄了好久，开始总是不能随意控制，技术太差，现在好多了，后台的异步也要让它停下来，线程池中也要让它停下来。)

523066680

多线程抓取网络数据的场景，耗时更多的仍然是网络部分。
即使是一个序列化数组（串行操作），若只是在push, shift操作的前后加锁和解锁（而不是在网络请求阶段就开始锁），占用的时间其实微不足道。

对于高性能并行运算的数据共享，不太了解。GPU Shader 的运算是可以并行处理最后直接输出值的，但是场景特殊。

比如10个线程，首先处理前10个坑，若其中一个线程先处理完了，它立即去处理第11个坑，已处理完的数据就留在坑里，这样直到所有的坑处理完为止

之前做过类似的做法，开10个常驻线程，他们从一个共享数组中获取任务并输出结果。也分为两种方式
1. 一开始就为线程分配等量的任务，不过有的线程会先处理完所有任务，提前进入空闲或者detach
2. 每个线程共享一个index索引，谁执行完了，就领取下一个任务。为了避免$index计数冲突, 依然要用到变量锁

后来改用队列

Thread::Queue 包为线程提供了线程安全的队列支持。与信号量类似，从内部实现上看，Thread::Queue 也是把一个通过锁机制实现同步访问的共享队列封装成了一个线程安全的包，并提供统一的使用接口。Thread::Queue 在某些情况下可以大大简化线程间通信的难度和成本。例如在生产者 - 消费者模型中，生产者可以不断地在线程队列上做 enqueue 操作，而消费者只需要不断地在线程队列上做 dequeue 操作，这就很简单地实现了生产者和消费者之间同步的问题。例如

再后来用上了 Mojolicious，省心

# Non-blocking request
$ua->get('mojolicious.org' => sub ($ua, $tx) { say $tx->result->dom->at('title')->text });
Mojo::IOLoop->start unless Mojo::IOLoop->is_running;
复制代码

my $wdir = "D:/blah";
for my $city ( keys %list )
{
    my $name = sprintf "%s/%s.json", $wdir, gbk($city);
    $query->{"toCountryId"} = $ct_code->{$city};  # 城市ID 更新到请求数据中
    $res = $ua->post( $url, to_json( $query ), closure->( $name ) );
}

$loop->start unless $loop->is_running;

sub closure ($file) {
    return sub ($ua, $tx) {
        printf "%s\n", $file;
        write_file( $file, $tx->result->body );
    }
}
复制代码

went

为了解决线程同步问题,锁定共享资源是必须的.但仅仅是访问该资源对象的时候只允许一个线程进入,这个过程往往时间很短甚至可以忽略.共享资源对象访问完毕后,线程执行任务时仍然是互不干扰的
对于多线程下载文件时,文件对象并不需要线程同步加锁,每个线程写入的数据段(开始位置和数据长度)都不同,本来就互不干扰,也就不存在线程同步问题
个人见解,希望能帮到你.

yhcfsr

大神来个实例，学习下