[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"$apiParty6fBuHLCPZ1LTYs42XHdVbjpSDOYYPYzyxeAGwSN5Tp8":3,"$apiParty2JzsjVuhUbyMqadoorlVsZlh-XFCu39CHtSztAerqww":563,"$apiParty2JzsjVuhUbyMqadoorlVsZlh-XFCu39CHtSztAerqww$H93EERW16b":563},{"product_data":4,"scene_data":21,"task_data":407,"modality_data":441,"domain_data":478},[5,9,12,15,18],{"name":6,"value":7,"add_value":8,"describe":8},"Rivo","1","",{"name":10,"value":11,"add_value":8,"describe":8},"Cubo","2",{"name":13,"value":14,"add_value":8,"describe":8},"Moye","3",{"name":16,"value":17,"add_value":8,"describe":8},"Juro","4",{"name":19,"value":20,"add_value":8,"describe":8},"Ordo","5",[22,73,135,197,232,267,302,337,372],{"name":23,"value":7,"add_value":24,"describe":25,"children":26},"Home & Indoor","sofa","AI enhances everyday home life. Our datasets cover real indoor scenes to support smart devices, robotics, and home intelligence.",[27,29,31,33,35,37,40,43,46,49,52,55,58,61,64,67,70],{"name":28,"value":7},"Living Room",{"name":30,"value":11},"Bedroom",{"name":32,"value":14},"Kitchen",{"name":34,"value":17},"Dining Area",{"name":36,"value":20},"Bathroom",{"name":38,"value":39},"Entrance \u002F Foyer","6",{"name":41,"value":42},"Corridor \u002F Hallway","7",{"name":44,"value":45},"Staircase","8",{"name":47,"value":48},"Home Office","9",{"name":50,"value":51},"Hobby \u002F Game Room","10",{"name":53,"value":54},"Worship Space","11",{"name":56,"value":57},"Garage","12",{"name":59,"value":60},"Utility \u002F Laundry Room","13",{"name":62,"value":63},"Pantry","14",{"name":65,"value":66},"Basement","15",{"name":68,"value":69},"Garden","16",{"name":71,"value":72},"Balcony","17",{"name":74,"value":11,"add_value":75,"describe":76,"children":77},"Office & Educational","workshop","AI is reshaping work and learning. Our datasets capture offices and classrooms to power automation and next-generation productivity tools.",[78,81,84,87,90,93,96,99,102,105,108,111,114,117,120,123,126,129,132],{"name":79,"value":80},"Open Office","18",{"name":82,"value":83},"Private Office","19",{"name":85,"value":86},"Co-working Space","20",{"name":88,"value":89},"Reception \u002F Lobby","21",{"name":91,"value":92},"Conference Room","22",{"name":94,"value":95},"Huddle Room \u002F Booth","23",{"name":97,"value":98},"Lecture Hall \u002F Auditorium","24",{"name":100,"value":101},"Classroom","25",{"name":103,"value":104},"Science Laboratory","26",{"name":106,"value":107},"Library","27",{"name":109,"value":110},"Design Studio","28",{"name":112,"value":113},"Pantry \u002F Breakroom","29",{"name":115,"value":116},"Cafeteria \u002F Canteen","30",{"name":118,"value":119},"Restroom (Commercial)","31",{"name":121,"value":122},"Gymnasium \u002F Sports Hall","32",{"name":124,"value":125},"Server Room","33",{"name":127,"value":128},"Mailroom \u002F Logistics","34",{"name":130,"value":131},"Janitorial Closet","35",{"name":133,"value":134},"Corridor \u002F Elevators","36",{"name":136,"value":14,"add_value":137,"describe":138,"children":139},"Healthcare & Medical","love-and-help","AI is advancing modern healthcare. Our datasets include clinics and hospitals to enable clinical insights and medical automation.",[140,143,146,149,152,155,158,161,164,167,170,173,176,179,182,185,188,191,194],{"name":141,"value":142},"Operating Theatre \u002F OR","37",{"name":144,"value":145},"Consultation Room","38",{"name":147,"value":148},"Treatment Room","39",{"name":150,"value":151},"Dental Clinic","40",{"name":153,"value":154},"Inpatient Ward","41",{"name":156,"value":157},"Nurse Station","42",{"name":159,"value":160},"ICU","43",{"name":162,"value":163},"NICU (Neonatal ICU)","44",{"name":165,"value":166},"Emergency Room (ER)","45",{"name":168,"value":169},"Hospital Corridor","46",{"name":171,"value":172},"Waiting Area","47",{"name":174,"value":175},"CT\u002FMRI","48",{"name":177,"value":178},"Medical Laboratory","49",{"name":180,"value":181},"Phlebotomy Room","50",{"name":183,"value":184},"Rehabilitation Gym","51",{"name":186,"value":187},"Assisted Living Room","52",{"name":189,"value":190},"Pharmacy","53",{"name":192,"value":193},"Sterile Processing Dept","54",{"name":195,"value":196},"Medical Storage","55",{"name":198,"value":17,"add_value":199,"describe":200,"children":201},"Business & Public Service","business","AI is elevating commercial and public services. Our datasets span retail, dining, and service centers to improve intelligent operations.",[202,205,208,211,214,217,220,223,226,229],{"name":203,"value":204},"Shopping Mall Atrium","86",{"name":206,"value":207},"Supermarket Shelf","87",{"name":209,"value":210},"Self-Checkout Counter","88",{"name":212,"value":213},"Restaurant Dining Hall","89",{"name":215,"value":216},"Commercial Kitchen","90",{"name":218,"value":219},"Hotel Lobby","91",{"name":221,"value":222},"Subway Platform","92",{"name":224,"value":225},"Security Checkpoint","93",{"name":227,"value":228},"Underground Parking","94",{"name":230,"value":231},"Bank Teller Zone","95",{"name":233,"value":20,"add_value":234,"describe":235,"children":236},"Industrial & Manufacturing","robot-arm","AI is modernizing industry. Our datasets capture factories and logistics spaces to support robotics and intelligent manufacturing.",[237,240,243,246,249,252,255,258,261,264],{"name":238,"value":239},"Final Assembly Line","96",{"name":241,"value":242},"Quality Control Station","97",{"name":244,"value":245},"Robotic Welding Cell","98",{"name":247,"value":248},"CNC Machining Center","99",{"name":250,"value":251},"Cleanroom","100",{"name":253,"value":254},"Automated Warehouse","101",{"name":256,"value":257},"Loading Dock","102",{"name":259,"value":260},"Sorting Center","103",{"name":262,"value":263},"Chemical Plant","104",{"name":265,"value":266},"Power Substation","105",{"name":268,"value":39,"add_value":269,"describe":270,"children":271},"Transportation & Driving","car","AI is revolutionizing mobility. Our datasets capture road networks, vehicle dynamics and traffic scenarios to support autonomous driving and intelligent transportation systems.",[272,275,278,281,284,287,290,293,296,299],{"name":273,"value":274},"Urban Intersection","56",{"name":276,"value":277},"Highway \u002F Expressway","57",{"name":279,"value":280},"Tunnel","58",{"name":282,"value":283},"Roundabout","59",{"name":285,"value":286},"School \u002F Hospital Zone","60",{"name":288,"value":289},"Toll Station","61",{"name":291,"value":292},"Construction Zone","62",{"name":294,"value":295},"Parking Garage","63",{"name":297,"value":298},"Driver Cabin","64",{"name":300,"value":301},"Adverse Weather","65",{"name":303,"value":42,"add_value":304,"describe":305,"children":306},"Outdoor & Construction","tent-tree","AI is optimizing outdoor operations. Our datasets capture construction sites, open-air work zones and outdoor infrastructure to support smart construction and autonomous outdoor machinery.",[307,310,313,316,319,322,325,328,331,334],{"name":308,"value":309},"Excavation Site","66",{"name":311,"value":312},"Scaffolding Area","67",{"name":314,"value":315},"Material Storage Yard","68",{"name":317,"value":318},"Site Entrance","69",{"name":320,"value":321},"Roadwork Zone","70",{"name":323,"value":324},"Bridge Infrastructure","71",{"name":326,"value":327},"Transmission Line","72",{"name":329,"value":330},"Open-pit Mine","73",{"name":332,"value":333},"Tunneling Site","74",{"name":335,"value":336},"Post-Disaster Rubble","75",{"name":338,"value":45,"add_value":339,"describe":340,"children":341},"Nature, Aerial & Aquatic","global-loop","AI is exploring the natural world. Our datasets capture terrestrial landscapes, aerial vistas and aquatic ecosystems to support environmental monitoring and autonomous exploration systems.",[342,345,348,351,354,357,360,363,366,369],{"name":343,"value":344},"Deep Forest","76",{"name":346,"value":347},"Farmland \u002F Crops","77",{"name":349,"value":350},"River \u002F Lake","78",{"name":352,"value":353},"Open Ocean","79",{"name":355,"value":356},"Underwater Coral Reef","80",{"name":358,"value":359},"Fish Farm","81",{"name":361,"value":362},"Mountain Terrain","82",{"name":364,"value":365},"Urban Low Altitude","83",{"name":367,"value":368},"Fire Scene","84",{"name":370,"value":371},"Desert \u002F Gobi","85",{"name":373,"value":48,"add_value":374,"describe":375,"children":376},"Virtul & Digital","siri","AI is reshaping the virtual realm. Our datasets capture digital twins, virtual environments and simulated spaces to support metaverse development and intelligent digital interaction.",[377,380,383,386,389,392,395,398,401,404],{"name":378,"value":379},"VR Social Space","106",{"name":381,"value":382},"Synthetic Driving Sim","107",{"name":384,"value":385},"Digital Twin City","108",{"name":387,"value":388},"FPS \u002F MOBA Game","109",{"name":390,"value":391},"Robotics Gym","110",{"name":393,"value":394},"AR Navigation","111",{"name":396,"value":397},"Virtual Showroom","112",{"name":399,"value":400},"Code \u002F IDE Interface","113",{"name":402,"value":403},"App GUI Screen","114",{"name":405,"value":406},"Synthetic Face\u002FID","115",[408,411,414,417,420,423,426,429,432,435,438],{"name":409,"value":7,"add_value":410,"describe":8},"Classification","rubric",{"name":412,"value":11,"add_value":413,"describe":8},"Detection","radar",{"name":415,"value":14,"add_value":416,"describe":8},"Segmentation","segmentation",{"name":418,"value":17,"add_value":419,"describe":8},"Tacking","crosshairs",{"name":421,"value":20,"add_value":422,"describe":8},"Estimation","streamline",{"name":424,"value":39,"add_value":425,"describe":8},"QA","qa",{"name":427,"value":42,"add_value":428,"describe":8},"Recognition","finger-scan",{"name":430,"value":45,"add_value":431,"describe":8},"Control","control",{"name":433,"value":48,"add_value":434,"describe":8},"Extraction","extraction",{"name":436,"value":51,"add_value":437,"describe":8},"Retrieval","retrieval",{"name":439,"value":54,"add_value":440,"describe":8},"Forecast","forecast",[442,445,448,451,454,457,460,463,466,469,472,475],{"name":443,"value":7,"add_value":444,"describe":8},"Audio","audio",{"name":446,"value":11,"add_value":447,"describe":8},"Image","image",{"name":449,"value":14,"add_value":450,"describe":8},"Text","text",{"name":452,"value":17,"add_value":453,"describe":8},"Video","video",{"name":455,"value":20,"add_value":456,"describe":8},"Multi","multi",{"name":458,"value":39,"add_value":459,"describe":8},"Document","document",{"name":461,"value":42,"add_value":462,"describe":8},"Time-Series","time-series",{"name":464,"value":45,"add_value":465,"describe":8},"3D cloud","cloud",{"name":467,"value":48,"add_value":468,"describe":8},"Code","code",{"name":470,"value":51,"add_value":471,"describe":8},"Event","event",{"name":473,"value":54,"add_value":474,"describe":8},"Motion","motion",{"name":476,"value":57,"add_value":477,"describe":8},"Interaction","interaction",[479,482,487,491,494,499,504,509,514,519,524,528,532,536,540,544,548,552,556,559],{"id":480,"value":480,"name":233,"intro":481,"add_value":234,"describe":481},2,"智能质检：利用图像识别、多模态模型对产品外观或声音、振动等数据进行分析，自动识别缺陷，提高质量控制效率。\n工业知识问答与文档理解：通过大模型理解和总结技术文档、操作手册，实现快速问答、知识检索和培训支持。\n安全监测与风险预警：实时分析视频、传感器和操作日志，识别潜在危险行为或异常状态，提前预警，保障人员和设备安全。",{"id":483,"value":483,"name":484,"intro":485,"add_value":486,"describe":485},3,"Finance & Insurance","风险评估与预测：分析大量客户数据，评估信用风险、市场风险等，预测违约概率、股价走势等，辅助金融机构决策。\n智能投顾：根据客户风险偏好、资产状况等，提供个性化投资组合建议，实时调整投资策略。\n反欺诈检测：通过分析交易数据、用户行为，识别异常交易和欺诈行为，保障金融安全。","funds",{"id":488,"value":488,"name":489,"intro":490,"add_value":269,"describe":490},1,"Transport & Automotive","智能座舱：打造多模态交互的 AI 座舱，通过语音、手势、面部识别等实现人机交互，如语音控制导航、音乐播放。\n驾驶员状态监测：识别疲劳、分心、抽烟、打电话等行为，通过大模型判断危险等级，触发相应提醒或干预机制。\n智能驾驶：AI 用于环境感知、路径规划与决策控制，使车辆能识别道路、行人、障碍物等，实现自适应巡航、自动泊车、车道保持等功能，提升驾驶安全性与便利性。",{"id":492,"value":492,"name":136,"intro":493,"add_value":137,"describe":493},4,"医学影像诊断：分析 CT、MRI 等影像，辅助医生检测疾病、识别病灶，如 AI 系统可快速发现肺部结节。\n医患对话助手：通过自然语言处理理解患者问题，提供初步健康建议或就诊指导，缓解医生接诊压力。\n智能健康管理：根据用户健康数据，提供个性化健康建议、疾病预警，如智能手环结合 AI 分析用户运动、睡眠、心率等数据。",{"id":495,"value":495,"name":496,"intro":497,"add_value":498,"describe":497},6,"Smart Devices","多模态交互：支持语音、手势、眼神等多种交互方式，如 AI 眼镜可通过语音指令实现翻译、搜索功能。\n智能感知与处理：使设备能感知环境、理解用户需求，如智能音箱根据环境噪音自动调节音量。\n个性化服务：根据用户使用习惯和偏好，提供个性化功能与服务，如智能手表为用户定制运动健身计划。","microscope",{"id":500,"value":500,"name":501,"intro":502,"add_value":503,"describe":502},8,"Law & Government","智能法律问答：面向公众或企业用户，提供合规、劳动法、婚姻继承、知识产权等常见法律问题的智能解答。\n合同审查与风险识别：利用大模型分析合同内容，识别潜在风险条款、漏洞或不合理约定，提升合同审核质量。\n法律知识图谱构建：自动梳理法规、案例、条文之间的引用关系，构建语义化知识图谱，支持智能分析和推理。","hammer",{"id":505,"value":505,"name":506,"intro":507,"add_value":508,"describe":507},7,"Education & Training","个性化学习：根据学生学习进度、能力和知识掌握情况，推送个性化学习内容与练习，如智能辅导系统为学生制定专属学习计划。\n智能教学辅助：AI 助教协助教师进行作业批改、答疑解惑，还可分析教学数据，为教师提供教学反馈，优化教学方法。\n虚拟学习环境：利用 AI 创建虚拟实验、历史场景等，让学生沉浸式学习，如在虚拟化学实验室中进行实验操作。","degree-hat",{"id":510,"value":510,"name":511,"intro":512,"add_value":513,"describe":512},5,"Agriculture & Food","作物病虫害识别与防治：通过图像识别分析农作物叶片、果实等症状，识别病虫害类型，给出防治建议，减少产量损失。\n农产品质量检测：利用图像和传感器数据，识别果蔬等农产品的成熟度、外观缺陷，进行自动分级，提高市场竞争力。\n农情监测与预测：利用卫星遥感、气象和传感器数据，结合大模型预测作物长势、干旱、洪涝等农情变化。","ph-farm",{"id":515,"value":515,"name":516,"intro":517,"add_value":518,"describe":517},9,"Retail & E-commerce","智能客服：通过自然语言对话理解用户需求，提供产品推荐、订单查询、退换货支持等服务，提升客户满意度。\n个性化营销推荐：基于用户浏览、购买、偏好等行为数据，生成个性化推荐内容与优惠策略，提高转化率和客单价。\n商品内容生成：自动撰写商品标题、卖点描述、使用说明等内容，适用于海量SKU的内容生产与多语言发布。","buy",{"id":520,"value":520,"name":521,"intro":522,"add_value":523,"describe":8},10,"Security & Protection",null,"safe-shield-line",{"id":525,"value":525,"name":526,"intro":522,"add_value":527,"describe":8},11,"Environment & Climate","weather",{"id":529,"value":529,"name":530,"intro":522,"add_value":531,"describe":8},12,"Energy & Resource","energy-leaf",{"id":533,"value":533,"name":534,"intro":522,"add_value":535,"describe":8},13,"Express & Logistics","speed-outline",{"id":537,"value":537,"name":538,"intro":522,"add_value":539,"describe":8},15,"Sports","baseball-outline",{"id":541,"value":541,"name":542,"intro":522,"add_value":543,"describe":8},16,"General Data","daily-booth",{"id":545,"value":545,"name":546,"intro":522,"add_value":547,"describe":8},17,"Content & Media","media",{"id":549,"value":549,"name":550,"intro":522,"add_value":551,"describe":8},18,"Construction","construction",{"id":553,"value":553,"name":554,"intro":522,"add_value":555,"describe":8},19,"IT & Telecom","tech",{"id":557,"value":557,"name":558,"intro":522,"add_value":498,"describe":8},20,"Science & Research",{"id":560,"value":560,"name":561,"intro":522,"add_value":562,"describe":8},21,"Language & Culture","lang",{"id":564,"unique_code":565,"title":566,"icon":8,"intro":567,"cate":483,"detail":568,"create_time":569,"update_time":570,"price":571,"view_count":572,"download_count":573,"unit":573,"amount":574,"is_create_order":573,"enterprise_id":488,"seo_keywords":575,"seo_description":576,"data_format":577,"file_size":578,"apply_scene":579,"training_task":580,"version":581,"dataset_type_id":492,"dataset_scene_id":553,"sample_file":582,"banner":8,"unit_name":8,"cate_name":449,"icon_url":8,"banner_url":8,"sample_file_url":8,"data_dict":583,"qa_list":630,"sample_metadatas":647,"text_sample_content":690,"enterprise_name":691,"enterprise_logo":692,"data_distribution":693},1138,"09298d82a767b9d3d07be0892c5ded8b","Distributed Cache Concurrency Control Code Understanding Dataset","Train models to identify concurrency mechanisms, shared state, and potential race conditions in distributed cache code through source-based question answering.","\u003Cp>This dataset contains distributed cache source code excerpts related to locks, atomic operations, concurrent updates, and request coalescing, paired with questions and answers about synchronization boundaries, shared state, and potential race paths. It helps models analyze concurrency mechanisms from source code and explain their effects on cache state, request responses, and other execution outcomes, making it suitable for code supervised fine-tuning and distributed cache code understanding. Dataset size and licensing terms are provided on the product page.\u003C\u002Fp>","2026-10-10 20:15:29","2026-10-19 17:19:34","0.00",34,0,5000,"distributed cache dataset, concurrency control code, cache source code, code understanding, code question answering, locks and atomic operations, request coalescing, code fine-tuning","A code fine-tuning dataset for distributed cache concurrency, covering locks, atomic operations, request coalescing, and source code analysis.","JSON","0.3GB","distributed cache management, concurrency control analysis, distributed system reliability","code understanding, race condition detection, concurrency mechanism analysis","V1.0","rivo\u002Fsample-packages\u002Fa22c6a21-0f28-4345-9036-fe24345980e7\u002F20261010.zip",[584,589,594,599,605,610,615,620,625],{"id":573,"name":585,"field":586,"intro":587,"type":588},"File Name","file_name","File name","string",{"id":590,"name":591,"field":592,"intro":593,"type":588},8278,"Analytical Answer","answer","An explanation of the concurrency logic based on the source code that addresses the question.",{"id":595,"name":596,"field":597,"intro":598,"type":588},8279,"Comprehension Question","question","A question about the source code, such as identifying synchronization boundaries, shared state, or potential race paths.",{"id":600,"name":601,"field":602,"intro":603,"type":604},8280,"Potential Race Paths","race_paths","Potential races caused by concurrent interleavings, insufficient synchronization scope, or shared state access, together with their possible effects.","array",{"id":606,"name":607,"field":608,"intro":609,"type":588},8281,"Source Code Excerpt","source_code","A distributed cache source code excerpt involving locks, atomic operations, concurrent updates, request coalescing, or related mechanisms.",{"id":611,"name":612,"field":613,"intro":614,"type":604},8282,"Shared State","shared_state","Cache state, flags, counters, or related data that may be accessed or modified by multiple execution paths.",{"id":616,"name":617,"field":618,"intro":619,"type":588},8283,"Execution Outcome","execution_result","The resulting cache state, request response, or other observable outcome after the relevant concurrent execution.",{"id":621,"name":622,"field":623,"intro":624,"type":588},8284,"Concurrency Control Mechanism","concurrency_mechanism","The locks, atomic operations, request coalescing, or other concurrency controls used in the source code and their purposes.",{"id":626,"name":627,"field":628,"intro":629,"type":604},8285,"Synchronization Boundaries","synchronization_boundaries","The locked regions, scope of atomic operations, or other synchronization boundaries, with the state or operations each protects.",[631,635,639,643],{"id":632,"question":633,"answer":634},6002,"What does the dataset contain?","It focuses on concurrency control in distributed cache code and includes source excerpts, comprehension questions, and analytical answers. Examples may address concurrency mechanisms, synchronization boundaries, shared state, execution outcomes, and potential race paths.",{"id":636,"question":637,"answer":638},6003,"Which training tasks is it suitable for?","It is suitable for code supervised fine-tuning, source code question answering, concurrency logic explanation, and race path analysis. It can help models interpret the roles of locks, atomic operations, concurrent updates, and request coalescing in cache code.",{"id":640,"question":641,"answer":642},6004,"How can I check the dataset specifications and quality?","Check the product page for available samples, field structure, dataset size, and quality information. The available description does not specify the number of records or programming language coverage, so review the latest listing before selection.",{"id":644,"question":645,"answer":646},6005,"How can I obtain the dataset, and what are the licensing terms?","Use the product page or the platform providing the dataset to check availability and acquisition options. Permitted uses, commercial rights, and other restrictions are governed by the relevant product listing or license agreement.",[648,664,677],{"id":649,"relate_table":650,"relate_id":651,"file_size":573,"file_name":652,"path":8,"duration":573,"cate":483,"file_format":653,"audio_rate":8,"audio_channel":522,"audio_bit_depth":522,"quality":8,"annotation":654,"cate_name":655,"answer":656,"question":657,"race_paths":658,"source_code":659,"shared_state":660,"execution_result":661,"concurrency_mechanism":662,"synchronization_boundaries":663},14815,"union_cubo",1316171406,"样例_3.json","json","{\"answer\": \"invalidate increments the key's epoch and removes its cached value while holding the same lock used by publication. When the earlier load finishes, it compares the current epoch with its captured epoch under the lock. If invalidation has occurred, the epochs differ, so load_and_publish returns False without storing that value. If two loads capture the same epoch and no invalidation occurs, each can pass the epoch check and publish; the one that acquires the lock later overwrites the earlier value. The method returns whether publication succeeded, not the loaded value.\", \"question\": \"What happens if invalidate runs after load_and_publish captures the key's epoch but before its loader finishes? Can two loads from the same epoch both publish?\", \"race_paths\": \"[\\\"A load can capture an epoch, then an invalidation can increment that epoch and remove the entry before the load finishes. The later publication check rejects the old load, preventing it from restoring a value from before the invalidation.\\\", \\\"Two loads can capture the same epoch and finish in either order. Since neither changes the epoch, both may publish; the later publication overwrites the earlier one.\\\"]\", \"source_code\": \"import threading\\n\\n\\nclass CacheWithInvalidationEpochs:\\n    def __init__(self):\\n        self._values = {}\\n        self._epochs = {}\\n        self._lock = threading.Lock()\\n\\n    def invalidate(self, key):\\n        with self._lock:\\n            self._epochs[key] = self._epochs.get(key, 0) + 1\\n            self._values.pop(key, None)\\n\\n    def load_and_publish(self, key, loader):\\n        with self._lock:\\n            epoch = self._epochs.get(key, 0)\\n\\n        value = loader()\\n\\n        with self._lock:\\n            if self._epochs.get(key, 0) != epoch:\\n                return False\\n            self._values[key] = value\\n            return True\", \"shared_state\": \"[\\\"_epochs maps keys to generation counters; invalidate increments a counter, and load_and_publish reads it before and after loading.\\\", \\\"_values maps keys to cached values; invalidate removes entries and load_and_publish may insert them, with those operations protected by _lock.\\\"]\", \"execution_result\": \"If the key's epoch is unchanged when publication is attempted, the value is stored and load_and_publish returns True. If the epoch changed, the value is not stored and the method returns False; the caller can use that result to decide whether to retry or discard the loaded value.\", \"concurrency_mechanism\": \"A per-key epoch acts as a generation token. A loader snapshots the token before doing work outside the lock, then checks it before publishing. Invalidation advances the token, preventing a load from an earlier generation from repopulating the cache.\", \"synchronization_boundaries\": \"[\\\"The lock in invalidate protects incrementing the key's epoch and removing its cached value as one operation.\\\", \\\"The first lock block in load_and_publish protects the epoch snapshot.\\\", \\\"The final lock block in load_and_publish protects comparing the current epoch with the snapshot and, when they match, storing the value.\\\"]\"}","文本","invalidate increments the key's epoch and removes its cached value while holding the same lock used by publication. When the earlier load finishes, it compares the current epoch with its captured epoch under the lock. If invalidation has occurred, the epochs differ, so load_and_publish returns False without storing that value. If two loads capture the same epoch and no invalidation occurs, each can pass the epoch check and publish; the one that acquires the lock later overwrites the earlier value. The method returns whether publication succeeded, not the loaded value.","What happens if invalidate runs after load_and_publish captures the key's epoch but before its loader finishes? Can two loads from the same epoch both publish?","[\"A load can capture an epoch, then an invalidation can increment that epoch and remove the entry before the load finishes. The later publication check rejects the old load, preventing it from restoring a value from before the invalidation.\", \"Two loads can capture the same epoch and finish in either order. Since neither changes the epoch, both may publish; the later publication overwrites the earlier one.\"]","import threading\n\n\nclass CacheWithInvalidationEpochs:\n    def __init__(self):\n        self._values = {}\n        self._epochs = {}\n        self._lock = threading.Lock()\n\n    def invalidate(self, key):\n        with self._lock:\n            self._epochs[key] = self._epochs.get(key, 0) + 1\n            self._values.pop(key, None)\n\n    def load_and_publish(self, key, loader):\n        with self._lock:\n            epoch = self._epochs.get(key, 0)\n\n        value = loader()\n\n        with self._lock:\n            if self._epochs.get(key, 0) != epoch:\n                return False\n            self._values[key] = value\n            return True","[\"_epochs maps keys to generation counters; invalidate increments a counter, and load_and_publish reads it before and after loading.\", \"_values maps keys to cached values; invalidate removes entries and load_and_publish may insert them, with those operations protected by _lock.\"]","If the key's epoch is unchanged when publication is attempted, the value is stored and load_and_publish returns True. If the epoch changed, the value is not stored and the method returns False; the caller can use that result to decide whether to retry or discard the loaded value.","A per-key epoch acts as a generation token. A loader snapshots the token before doing work outside the lock, then checks it before publishing. Invalidation advances the token, preventing a load from an earlier generation from repopulating the cache.","[\"The lock in invalidate protects incrementing the key's epoch and removing its cached value as one operation.\", \"The first lock block in load_and_publish protects the epoch snapshot.\", \"The final lock block in load_and_publish protects comparing the current epoch with the snapshot and, when they match, storing the value.\"]",{"id":665,"relate_table":650,"relate_id":666,"file_size":573,"file_name":667,"path":8,"duration":573,"cate":483,"file_format":653,"audio_rate":8,"audio_channel":522,"audio_bit_depth":522,"quality":8,"annotation":668,"cate_name":655,"answer":669,"question":670,"race_paths":671,"source_code":672,"shared_state":673,"execution_result":674,"concurrency_mechanism":675,"synchronization_boundaries":676},14814,476508625,"样例_2.json","{\"answer\": \"Both calls can run loader because each releases _lock before invoking it. When they attempt publication, compare_and_set checks the current version and replaces the entry only if it still equals the version each call read. The first successful call increments the version; the other then sees a mismatch and returns False, so both results cannot be published from that same starting version. The loader computation itself may nevertheless be duplicated, and the code does not serialize any side effects performed by loader.\", \"question\": \"If two refresh calls read the same entry version before either loader finishes, can both publish their results? What work may still be duplicated?\", \"race_paths\": \"[\\\"Two refresh calls can snapshot the same version and run their loaders concurrently. The first successful compare_and_set advances the version; the other call is rejected and returns False.\\\", \\\"Because the loader runs outside the lock, its computation can be based on a value that another refresh has since replaced. The version check prevents that stale computation from overwriting the newer entry, but it does not prevent duplicated loader work or side effects.\\\"]\", \"source_code\": \"import threading\\n\\n\\nclass VersionedCache:\\n    def __init__(self):\\n        self._entries = {}\\n        self._lock = threading.Lock()\\n\\n    def compare_and_set(self, key, expected_version, new_value):\\n        with self._lock:\\n            current = self._entries.get(key)\\n            if current is None or current[1] != expected_version:\\n                return False\\n            self._entries[key] = (new_value, expected_version + 1)\\n            return True\\n\\n    def refresh(self, key, loader):\\n        with self._lock:\\n            current = self._entries.get(key)\\n            if current is None:\\n                return False\\n            value, version = current\\n\\n        new_value = loader(value)\\n        return self.compare_and_set(key, version, new_value)\", \"shared_state\": \"[\\\"_entries maps each key to a (value, version) pair; its reads and writes in these methods are protected by _lock.\\\", \\\"The entry version is shared coordination state: compare_and_set reads it and increments it when a replacement succeeds.\\\"]\", \"execution_result\": \"refresh returns False if the key is absent when it takes its snapshot, or if its computed result loses the version check. It returns True when its result is stored and the entry version is incremented by one.\", \"concurrency_mechanism\": \"A mutex makes the version check and entry replacement one critical section. refresh uses an optimistic pattern: it reads a value and version under the lock, computes outside the lock, then conditionally publishes only if the version is unchanged.\", \"synchronization_boundaries\": \"[\\\"The first with self._lock block in refresh protects reading the entry and its version.\\\", \\\"The with self._lock block in compare_and_set protects the version comparison and replacement as one indivisible operation relative to other accesses using this instance's lock.\\\", \\\"loader(value) runs outside the lock, so concurrent refresh computations may overlap.\\\"]\"}","Both calls can run loader because each releases _lock before invoking it. When they attempt publication, compare_and_set checks the current version and replaces the entry only if it still equals the version each call read. The first successful call increments the version; the other then sees a mismatch and returns False, so both results cannot be published from that same starting version. The loader computation itself may nevertheless be duplicated, and the code does not serialize any side effects performed by loader.","If two refresh calls read the same entry version before either loader finishes, can both publish their results? What work may still be duplicated?","[\"Two refresh calls can snapshot the same version and run their loaders concurrently. The first successful compare_and_set advances the version; the other call is rejected and returns False.\", \"Because the loader runs outside the lock, its computation can be based on a value that another refresh has since replaced. The version check prevents that stale computation from overwriting the newer entry, but it does not prevent duplicated loader work or side effects.\"]","import threading\n\n\nclass VersionedCache:\n    def __init__(self):\n        self._entries = {}\n        self._lock = threading.Lock()\n\n    def compare_and_set(self, key, expected_version, new_value):\n        with self._lock:\n            current = self._entries.get(key)\n            if current is None or current[1] != expected_version:\n                return False\n            self._entries[key] = (new_value, expected_version + 1)\n            return True\n\n    def refresh(self, key, loader):\n        with self._lock:\n            current = self._entries.get(key)\n            if current is None:\n                return False\n            value, version = current\n\n        new_value = loader(value)\n        return self.compare_and_set(key, version, new_value)","[\"_entries maps each key to a (value, version) pair; its reads and writes in these methods are protected by _lock.\", \"The entry version is shared coordination state: compare_and_set reads it and increments it when a replacement succeeds.\"]","refresh returns False if the key is absent when it takes its snapshot, or if its computed result loses the version check. It returns True when its result is stored and the entry version is incremented by one.","A mutex makes the version check and entry replacement one critical section. refresh uses an optimistic pattern: it reads a value and version under the lock, computes outside the lock, then conditionally publishes only if the version is unchanged.","[\"The first with self._lock block in refresh protects reading the entry and its version.\", \"The with self._lock block in compare_and_set protects the version comparison and replacement as one indivisible operation relative to other accesses using this instance's lock.\", \"loader(value) runs outside the lock, so concurrent refresh computations may overlap.\"]",{"id":678,"relate_table":650,"relate_id":679,"file_size":573,"file_name":680,"path":8,"duration":573,"cate":483,"file_format":653,"audio_rate":8,"audio_channel":522,"audio_bit_depth":522,"quality":8,"annotation":681,"cate_name":655,"answer":682,"question":683,"race_paths":684,"source_code":685,"shared_state":686,"execution_result":687,"concurrency_mechanism":688,"synchronization_boundaries":689},14813,689531772,"样例_1.json","{\"answer\": \"The lock serializes the cache lookup and the decision to create or join a per-key flight. The leader runs loader outside the lock, so unrelated keys—and other code using the cache—are not blocked by the loader itself. Callers that find an existing flight wait on its event. On success, the leader stores the value and places it on the flight before signaling; waiters then return that value. On failure, the leader records the exception, removes the flight, and signals waiters, which raise the recorded exception. A later call after the failed flight has been removed can start a new load.\", \"question\": \"For concurrent calls to get_or_load with the same key, which work is serialized, and what do waiting callers observe if the loader raises an exception?\", \"race_paths\": \"[\\\"If several callers miss the same key concurrently, the first caller to insert a flight becomes leader; the others observe that flight and wait rather than invoking loader themselves.\\\", \\\"After a failed flight is removed, a new caller can create a new flight while callers from the failed flight are still waking and handling its exception. The new caller retries the load; the old waiters still refer to the completed flight object.\\\"]\", \"source_code\": \"import threading\\n\\n\\nclass _Flight:\\n    def __init__(self):\\n        self.event = threading.Event()\\n        self.value = None\\n        self.error = None\\n\\n\\nclass Cache:\\n    def __init__(self):\\n        self._values = {}\\n        self._flights = {}\\n        self._lock = threading.Lock()\\n\\n    def get_or_load(self, key, loader):\\n        with self._lock:\\n            if key in self._values:\\n                return self._values[key]\\n            flight = self._flights.get(key)\\n            leader = flight is None\\n            if leader:\\n                flight = _Flight()\\n                self._flights[key] = flight\\n\\n        if not leader:\\n            flight.event.wait()\\n            if flight.error is not None:\\n                raise flight.error\\n            return flight.value\\n\\n        try:\\n            value = loader()\\n        except Exception as exc:\\n            with self._lock:\\n                flight.error = exc\\n                self._flights.pop(key, None)\\n                flight.event.set()\\n            raise\\n\\n        with self._lock:\\n            self._values[key] = value\\n            flight.value = value\\n            self._flights.pop(key, None)\\n            flight.event.set()\\n        return value\", \"shared_state\": \"[\\\"_values maps keys to cached values; reads and writes in this method occur under _lock.\\\", \\\"_flights maps keys to shared _Flight objects; the map is accessed under _lock, while each flight's value, error, and event communicate the outcome to its waiters.\\\"]\", \"execution_result\": \"For a successful load, the value is cached and returned by the leader and callers waiting on that flight. If loading raises an Exception, the leader re-raises it and waiters raise the recorded exception; the failed flight is removed, so a subsequent call may try loading again.\", \"concurrency_mechanism\": \"A mutex protects the cache and per-key in-flight map, while an event lets callers for the same missing key share the leader's result or exception. This coalesces concurrent loads for a key while the flight remains registered.\", \"synchronization_boundaries\": \"[\\\"The with self._lock blocks protect checking and updating _values and looking up, inserting, or removing entries in _flights.\\\", \\\"flight.event.wait() blocks followers until the leader has stored either the result or the exception and signaled completion.\\\", \\\"loader() runs outside the mutex; its execution is not serialized by this cache lock.\\\"]\"}","The lock serializes the cache lookup and the decision to create or join a per-key flight. The leader runs loader outside the lock, so unrelated keys—and other code using the cache—are not blocked by the loader itself. Callers that find an existing flight wait on its event. On success, the leader stores the value and places it on the flight before signaling; waiters then return that value. On failure, the leader records the exception, removes the flight, and signals waiters, which raise the recorded exception. A later call after the failed flight has been removed can start a new load.","For concurrent calls to get_or_load with the same key, which work is serialized, and what do waiting callers observe if the loader raises an exception?","[\"If several callers miss the same key concurrently, the first caller to insert a flight becomes leader; the others observe that flight and wait rather than invoking loader themselves.\", \"After a failed flight is removed, a new caller can create a new flight while callers from the failed flight are still waking and handling its exception. The new caller retries the load; the old waiters still refer to the completed flight object.\"]","import threading\n\n\nclass _Flight:\n    def __init__(self):\n        self.event = threading.Event()\n        self.value = None\n        self.error = None\n\n\nclass Cache:\n    def __init__(self):\n        self._values = {}\n        self._flights = {}\n        self._lock = threading.Lock()\n\n    def get_or_load(self, key, loader):\n        with self._lock:\n            if key in self._values:\n                return self._values[key]\n            flight = self._flights.get(key)\n            leader = flight is None\n            if leader:\n                flight = _Flight()\n                self._flights[key] = flight\n\n        if not leader:\n            flight.event.wait()\n            if flight.error is not None:\n                raise flight.error\n            return flight.value\n\n        try:\n            value = loader()\n        except Exception as exc:\n            with self._lock:\n                flight.error = exc\n                self._flights.pop(key, None)\n                flight.event.set()\n            raise\n\n        with self._lock:\n            self._values[key] = value\n            flight.value = value\n            self._flights.pop(key, None)\n            flight.event.set()\n        return value","[\"_values maps keys to cached values; reads and writes in this method occur under _lock.\", \"_flights maps keys to shared _Flight objects; the map is accessed under _lock, while each flight's value, error, and event communicate the outcome to its waiters.\"]","For a successful load, the value is cached and returned by the leader and callers waiting on that flight. If loading raises an Exception, the leader re-raises it and waiters raise the recorded exception; the failed flight is removed, so a subsequent call may try loading again.","A mutex protects the cache and per-key in-flight map, while an event lets callers for the same missing key share the leader's result or exception. This coalesces concurrent loads for a key while the flight remains registered.","[\"The with self._lock blocks protect checking and updating _values and looking up, inserting, or removing entries in _flights.\", \"flight.event.wait() blocks followers until the leader has stored either the result or the exception and signaled completion.\", \"loader() runs outside the mutex; its execution is not serialized by this cache lock.\"]","{\"answer\":\"invalidate increments the key's epoch and removes its cached value while holding the same lock used by publication. When the earlier load finishes, it compares the current epoch with its captured epoch under the lock. If invalidation has occurred, the epochs differ, so load_and_publish returns False without storing that value. If two loads capture the same epoch and no invalidation occurs, each can pass the epoch check and publish; the one that acquires the lock later overwrites the earlier value. The method returns whether publication succeeded, not the loaded value.\",\"question\":\"What happens if invalidate runs after load_and_publish captures the key's epoch but before its loader finishes? Can two loads from the same epoch both publish?\",\"race_paths\":\"[\\\"A load can capture an epoch, then an invalidation can increment that epoch and remove the entry before the load finishes. The later publication check rejects the old load, preventing it from restoring a value from before the invalidation.\\\", \\\"Two loads can capture the same epoch and finish in either order. Since neither changes the epoch, both may publish; the later publication overwrites the earlier one.\\\"]\",\"source_code\":\"import threading\\n\\n\\nclass CacheWithInvalidationEpochs:\\n    def __init__(self):\\n        self._values = {}\\n        self._epochs = {}\\n        self._lock = threading.Lock()\\n\\n    def invalidate(self, key):\\n        with self._lock:\\n            self._epochs[key] = self._epochs.get(key, 0) + 1\\n            self._values.pop(key, None)\\n\\n    def load_and_publish(self, key, loader):\\n        with self._lock:\\n            epoch = self._epochs.get(key, 0)\\n\\n        value = loader()\\n\\n        with self._lock:\\n            if self._epochs.get(key, 0) != epoch:\\n                return False\\n            self._values[key] = value\\n            return True\",\"shared_state\":\"[\\\"_epochs maps keys to generation counters; invalidate increments a counter, and load_and_publish reads it before and after loading.\\\", \\\"_values maps keys to cached values; invalidate removes entries and load_and_publish may insert them, with those operations protected by _lock.\\\"]\",\"execution_result\":\"If the key's epoch is unchanged when publication is attempted, the value is stored and load_and_publish returns True. If the epoch changed, the value is not stored and the method returns False; the caller can use that result to decide whether to retry or discard the loaded value.\",\"concurrency_mechanism\":\"A per-key epoch acts as a generation token. A loader snapshots the token before doing work outside the lock, then checks it before publishing. Invalidation advances the token, preventing a load from an earlier generation from repopulating the cache.\",\"synchronization_boundaries\":\"[\\\"The lock in invalidate protects incrementing the key's epoch and removing its cached value as one operation.\\\", \\\"The first lock block in load_and_publish protects the epoch snapshot.\\\", \\\"The final lock block in load_and_publish protects comparing the current epoch with the snapshot and, when they match, storing the value.\\\"]\"}","MOBIUSI INC","https:\u002F\u002Fstatic.mobiusi.com\u002Fmobiwusi\u002F20250829\u002F7bf4ac62b4533e2b809998a6f1c5491e.png?Expires=1792463130&OSSAccessKeyId=LTAI5tH8MQqhgeiAtrzCHrxM&Signature=v6Tr8jBrdm4s5wU1SnnyGsYg%2Bhw%3D&x-oss-process=image%2Fresize%2Cm_fill%2Cw_35%2Ch_35",[694,700],{"type":695,"title":696,"count_data":697},"bar","Length distribution",[698],{"name":699,"value":483},"1k lower",{"type":701,"title":702,"count_data":703},"pie","Language distribution",[704],{"name":705,"value":483},"English"]