1.协同程序Lua 协同程序(coroutine)与线程比较类似:拥有独立的堆栈,独立的局部变量,独立的指令指针,同时又与其它协同程序共享全局变量和其它大部分东西。1.1 线程和协同程序区别线程与协同程序的主要区别在于,一个具有多个线程的程序可以同时运行几个线程,而协同程序却需要彼此协作的运行。在任一指定时刻只有一个协同程序在运行,并且这个正在运行的协同程序只有在明确的被要求挂起的时候才会被挂起。            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-23 16:55:52
                            
                                104阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Linux-Lua高级教学Lua 协同程序什么是协同?Lua 协同程序(coroutine)与线程比较类似:拥有独立的堆栈,独立的局部变量,独立的指令指针,同时又与其它协同程序共享全局变量和其它大部分东西。协同是非常强大的功能,但是用起来也很复杂。线程和协同程序区别线程与协同程序的主要区别在于,一个具有多个线程的程序可以同时运行几个线程,而协同程序却需要彼此协作的运行。在任一指定时刻只有一个协同程            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-05-11 11:46:21
                            
                                41阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            1.互斥锁 在线程实际运行过程中,我们经常需要多个线程保持同步。这时可以用互斥锁来完成任务。1.1锁的创建 互斥锁可以动态或静态的被创建,可以用宏PTHREAD_MUTEX_INITIALIZER来静态的初始化锁,采用这种方式比较容易理解,互斥锁是pthread_mutex_t的结构体,而这个宏是一个结构常量,如下可以完成静态的初始化锁: pthread_mutex_t mutex =PTHREA            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-16 09:59:04
                            
                                91阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            最近写paintsnow::start时出现了一个非常麻烦的BUG,程序的Release版本大约每运行十几次就会有一次启动时崩溃(Debug版本还没崩溃过),崩溃点也不固定。经过简单分析之后,确定是线程同步的问题。于是便修改了线程通信的代码,并使用pthread_mutex_lock/unlock来防止冲突。重新编译后,崩溃频率有所减少。但是每运行约四十次,还是免不了崩溃一次,而且冷启动时崩溃            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-03 15:25:42
                            
                                88阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Lua所支持的协程全称被称作协同式多线程(collaborative multithreading)。Lua为每个coroutine提供一个独立的运行线路。然而和多线程不同的地方就是,coroutine只有在显式调用yield函数后才被挂起,同一时间内只有一个协程正在运行。Lua将它的协程函数都放进了coroutine这个表里,其中主要的函数如下摘取一段云风的代码来详尽解释协程的工作机制,在这段代            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-05-11 08:18:25
                            
                                159阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            多线程的概念不太明确,所以这一章,还是没有和线程技术对比来理解。这一章对协同程序的应用和前面提到的过滤器和迭代器不同。  无论是在过滤器和迭代器中,即使有多个协同程序,协同程序之间两两之间都有关系。  比方说,在过滤器中,生成者如果通过函数coroutine.yield(x)将程序挂起,就会把x传递给函数coroutine.resume()作为这个函数的返回值,过滤器拿到这个返回值作为下一个协同函            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-23 14:48:59
                            
                                46阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            1 基于Redis分布式锁的问题先来看看之前分布式锁的实现。这个基于Redis的分布式锁仍然有着一个问题,那就是误删锁的问题。 简单的来说,就是当第一个线程,也就是线程1,拿到锁后,但由于本身业务复杂,而导致了阻塞,超过了锁设置的超时时间,锁自动释放。这个时候,线程2进来了,也拿到了锁,但是就在线程2执行业务的途中,线程1业务完成,主动释放了锁,又因为我们释放锁的逻辑是直接删除key,这            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-13 17:49:01
                            
                                77阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            最近在看些c#的代码,发现很多是以前没有接触到了,只能上网查,把比较好的整理下来。经常碰到同时需要对某个数据进行操作,或者对某个文件进行读写操作,对于这些操作我们以前往往不能很好的进行处理,自从C#语言中引入了lock这个关键字,以上问题就比较容易予以解决了,下面就是一段简单的代码。 public class AccessControl()
{
    private static object             
                
         
            
            
            
            声明:本文来自滴水公司于海东老师的课程。 ThreadSwitch.h
#pragma once
 
//最大支持的线程数
#define MAXGMTHREAD 100
 
//线程信息的结构
typedef struct 
{
    char* name; //线程名
    int Flags; //线程状态
    int SleepMillsecondDot; //休眠时间            
                
         
            
            
            
            1、coroutine运行一系列的协作多线程。每个coroutine相当于一个thread。通过yield-resume实现在不同thread之间切换控制权。但是,跟常规的多线程不同,coroutine是非抢占式的。一个coroutine在运行的时候,不可能被其他的coroutine从外部将其挂起,只有由其本身显式地调用yield才会挂起,并交出控制权。对            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-17 12:14:04
                            
                                99阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            Lua 协同程序(coroutine)什么是协同(coroutine)?      Lua 协同程序(coroutine)与线程比较类似:拥有独立的堆栈,独立的局部变量,独立的指令指针,同时又与其它协同程序共享全局变量和其它大部分东西。协同是非常强大的功能,但是用起来也很复杂。线程和协同程序区别一个具有多个线程的程序可以同时运行几个线程,            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-05-29 20:01:03
                            
                                54阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            # Redis 锁 Lua 实现
## 概述
本文将教会刚入行的开发者如何使用 Redis 的 Lua 脚本实现分布式锁。我们将从整体流程出发,逐步介绍每个步骤需要做什么,并提供相应的代码和注释。
## 整体流程
下面是实现 Redis 锁的整体流程,通过表格展示每个步骤:
| 步骤 | 描述 |
| ---- | ---- |
| 1 | 连接 Redis 服务器 |
| 2 | 构建            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-08-18 15:32:20
                            
                                72阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            # 使用 RedisTemplate 实现 Lua 锁
## 介绍
在分布式系统中,为了保证数据一致性和并发控制,经常需要使用分布式锁。Redis 是一种高性能的键值存储数据库,广泛应用于分布式系统中。Redis 的支持 Lua 脚本的特性使得实现分布式锁变得相对简单。本文将详细介绍如何使用 RedisTemplate 实现 Lua 锁,并提供了实现该功能所需的代码示例和详细解释。
## 流            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-11-26 09:57:15
                            
                                54阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            锁 lock 互斥锁什么是Python进程锁?Python进程锁如何创建和关闭进程是系统进行资源分配和调度的基本单位,当一个python程序在运行时就会给它分配单个或者是多个进程来利用资源。那想在python中将某一个任务进程锁住不让它被其他对象访问的话就要用到进程锁了,下面来给大家介绍python进程锁的含义和使用方法。from multiprocessing import Process,Lo            
                
         
            
            
            
            # 如何使用Redis Lua实现分布式锁
## 介绍
在分布式系统中,实现分布式锁是一个常见的需求。Redis作为一种高性能的内存数据库,提供了多种方式来实现分布式锁。其中,使用Redis Lua脚本是一种常见且可靠的方式。本文将教你如何使用Redis Lua实现分布式锁。
## 整体流程
下面是使用Redis Lua实现分布式锁的整体流程:
```mermaid
journey            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2024-01-24 11:19:41
                            
                                41阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            源码中7大参数位置:七大参数: 拒绝请求执行的runnable的策略。理解图:1. corePoolSize线程池中的常驻核心线程数3. keepAliveTime多余的线程存活核心线程满了,阻塞队列也满了,才会开启max最大线程数,如果还是满了,就会启动拒绝策略。如果流量降下来,就按照设置的时间最大数,慢慢的回到了核心线程数。原理:注意:阿里巴巴规范拒绝策略:public class Threa            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-09-03 06:43:26
                            
                                50阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            本人表达能力有限,所以文字描述不太清晰,我更习惯自己默默地造轮子,所以我只能尽力保证我给轮子可以被直接使用。虽然不太会说,但有一些前提还是必要讲一下的:直观的讲:lua并不支持多线程,任何尝试用lua做并发方案的人,都有病,没错,我自己也是。lua有并发需求本身就是一件很鬼扯的事,本身会有这种需求,就说明可能在项目架构的大方向上,存在了问题。我认为对于C/C++程序员来说,我们看中lua的地方是,            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-01 12:43:14
                            
                                211阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Lua 中多线程用法 for Win32Exts            目前 Lua 中并没有 真正的抢占式 thread 的概念,只有一个类似的协程:coroutine 对象,同一时间只能运行一个 coroutine ,并且需要显式的进行切换才能执行。与实际应用需求相差甚远。(coroutine 用法参见:            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-06 15:14:31
                            
                                100阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            什么是分布式锁? 控制分布式架构中多个模块访问的优先级要介绍分布式锁,首先要提到与分布式锁相对应的是线程锁、进程锁。线程锁:主要用来给方法、代码块加锁。当某个方法或代码使用锁,在同一时刻仅有一个线程执行该方法或该代码段。线程锁只在同一JVM中有效果,因为线程锁的实现在根本上是依靠线程之间共享内存实现的,比如synchronized是共享对象头,显示锁Lock是共享某个变量(state)。进程锁:为            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-12-21 16:05:18
                            
                                49阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            前言本文主要讲解 lua 协程的基本使用,和它在 skynet 这个框架中的实际应用。skynet简介可能有的读者学 lua 不是做游戏服务器的,没有了解过 skynet,简单介绍下,skynet 是 云风 大神开发的开源服务器引擎,应用于当下众多的游戏公司的服务器框架。lua协程是什么从多线程(multithreading)的角度看,协程(coroutine)与线程(thread)类似:协程是一            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-05-05 17:58:28
                            
                                63阅读