Lock (computer science) (original) (raw)
Zámek je v informatice označení synchronizačního primitiva pro zajištění výhradního přístupu k systémovým prostředkům (místo v operační paměti, vstupně-výstupní nebo jiný hardware připojený k počítači) ve víceúlohovém prostředí, kde tak brání souběhu. Zámky jsou používány jak v případě, že dochází k cyklickému přepínání mezi běžícími úlohami, tak při skutečně paralelním běhu úloh ve víceprocesorových systémech. Typické je použití v multithreadových programech, například v Javě.
| Property | Value |
|---|---|
| dbo:abstract | En ciències de la computació, els cadenats d'exclusió mútua o "locks" (anglès) són un mecanisme de sincronització que limita l'accés a un recurs compartit per diversos processos o fils en un ambient d'execució concurrent, permetent així l'exclusió mútua. Quan un element és compartit per més d'un fil, poden ocórrer condicions de competició si aquest no és protegit adequadament. El mecanisme més simple per a la protecció és el cadenat o tanca .En general quan ha de protegir un conjunt d'elements, se li associa un cadenat. Cada procés/fil per a tenir accés a un element del conjunt, haurà de bloquejar, de manera que es converteix en el seu amo. Aquesta és l'única forma de guanyar accés. En acabar d'usar-lo, el propietari ha de desbloquejar, per permetre que un altre procés/fil pugui prendre al seu torn. És possible que mentre un procés/fil estigui accedint a un recurs (sent per tant propietari del cadenat), un altre procés/fil intenti accedir. Aquesta acció ha d'esperar fins que el cadenat es trobi lliure, per garantir l'exclusió mútua. El procés/fil sol·licitant queda llavors en espera o passa a estat de bloqueig segons l'algorisme implementat. Quan el propietari del cadenat el desbloqueja pot prendre'l algun dels processos/fils que esperaven. Aquest mecanisme es pot veure en un exemple de la vida real. Suposem un lavabo públic, on només pot entrar una persona a la vegada. Un cop dins, s'empra un cadenat per evitar que entrin altres persones. Si una altra persona pretén fer servir el lavabo quan està ocupat, haurà de quedar esperant que la persona que va entrar abans acabi. Si més persones arribessin, formarien una cua (del tipus FIFO) i esperarien el seu torn. En informàtica, el programador no ha d'assumir aquest tipus de comportament a la cua d'espera. El cadenat, usat d'aquesta manera, forma una secció crítica En cada procés/fil, des que és pres fins que s'allibera. En l'exemple del lavabo, dins de la secció crítica es troben les funcions que es realitzen generalment dins d'aquest tipus d'instal·lacions sanitàries. Com garanteixen l'exclusió mútua, moltes vegades se'ls anomena mutex (per mutual exclusion ). En general hi ha un nombre de restriccions sobre els cadenats, encara que no són les mateixes en tots els sistemes. Aquestes són: * Només el propietari d'un cadenat pot desbloquejar * La readquisició d'un cadenat no està permesa Una cosa molt important és que tots els processos/fils han d'utilitzar el mateix protocol per bloquejar i desbloquejar els cadenats en l'accés als recursos, ja que si mentre dos processos/fils utilitzen el cadenat de forma correcta, hi ha un altre que simplement accedeix a les dades protegits, no es garanteix l'exclusió mútua i poden donar-se condicions de competició i errors en els resultats. (ca) Zámek je v informatice označení synchronizačního primitiva pro zajištění výhradního přístupu k systémovým prostředkům (místo v operační paměti, vstupně-výstupní nebo jiný hardware připojený k počítači) ve víceúlohovém prostředí, kde tak brání souběhu. Zámky jsou používány jak v případě, že dochází k cyklickému přepínání mezi běžícími úlohami, tak při skutečně paralelním běhu úloh ve víceprocesorových systémech. Typické je použití v multithreadových programech, například v Javě. (cs) القفل مصطلح مستعمل في ميدان الحوسبة المتوازية، والقفل هو آلية تزامن لتأمين تطبيق قيود على الوصول إلى مورد في بيئة حيث يتم تنفيذ عدة خيوط. فيصبح الوصول مؤمن لطالب واحد في نفس الوقت. الأقفال أحد الطرق لإنفاذ سياسات مراقبة التزامن. كما أن الأقفال مستعمل أيضا في أنظمة التشغيل متعددة المستخدمين. (ar) Unter einem Lock oder Locking (englisch für Sperre oder Sperren) versteht man in der Informatik das Sperren des Zugriffs auf ein Betriebsmittel. Eine solche Sperre ermöglicht den exklusiven Zugriff eines Prozesses auf eine Ressource, d. h. mit der Garantie, dass kein anderer Prozess diese Ressource liest oder verändert, solange die Sperre besteht. Locking wird häufig bei Prozesssynchronisation sowie in Datei- und Datenbanksystemen verwendet, um atomare und konsistente Lese- und Schreibanforderungen zu gewährleisten. (de) En ciencias de la computación, los cierres de exclusión mutua, candados o mutex son un mecanismo de sincronización que limita el acceso a un recurso compartido por varios procesos o hilos en un ambiente de ejecución concurrente, permitiendo así la exclusión mutua. Cuando un elemento es compartido por más de un hilo, pueden ocurrir condiciones de carrera si el mismo no es protegido adecuadamente. El mecanismo más simple para la protección es el cierre o cerrojo. En general cuando debe protegerse un conjunto de elementos, se le asocia un cerrojo. Cada proceso/hilo para tener acceso a un elemento del conjunto, deberá bloquear, con lo que se convierte en su dueño. Esa es la única forma de ganar acceso. Al terminar de usarlo, el dueño debe desbloquear, para permitir que otro proceso/hilo pueda tomarlo a su vez. Es posible que mientras un proceso/hilo esté accediendo a un recurso (siendo por lo tanto dueño del cerrojo), otro proceso/hilo intente acceder. Esta acción debe esperar hasta que el cerrojo se encuentre libre, para garantizar la exclusión mutua. El proceso/hilo solicitante queda entonces en espera o pasa a estado de bloqueo según el algoritmo implementado. Cuando el dueño del cerrojo lo desbloquea puede tomarlo alguno de los procesos/hilos que esperaban. Este mecanismo se puede ver en un ejemplo de la vida real. Supongamos un baño público, donde solo puede entrar una persona a la vez. Una vez dentro, se emplea un cierre para evitar que entren otras personas. Si otra persona pretende usar el baño cuando está ocupado, deberá quedar esperando a que la persona que entró anteriormente termine. Si más personas llegaran, formarían una cola (del tipo FIFO) y esperarían su turno. En informática, el programador no debe asumir este tipo de comportamiento en la cola de espera. El cerrojo, usado de esta manera, forma una sección crítica en cada proceso/hilo, desde que es tomado hasta que se libera. En el ejemplo del baño, dentro de la sección crítica se encuentran las funciones que se realizan generalmente dentro de este tipo de instalaciones sanitarias. Como garantizan la exclusión mutua, muchas veces se los denomina mutex (por mutual exclusion). En general hay un número de restricciones sobre los cerrojos, aunque no son las mismas en todos los sistemas. Estas son: * Sólo el dueño de un cerrojo puede desbloquearlo * La readquisición de un cerrojo no está permitida Algo muy importante es que todos los procesos/hilos deben utilizar el mismo protocolo para bloquear y desbloquear los cerrojos en el acceso a los recursos, ya que si mientras dos procesos/hilos utilizan el cerrojo de forma correcta, existe otro que simplemente accede a los datos protegidos, no se garantiza la exclusión mutua y pueden darse condiciones de carrera y errores en los resultados. (es) In computer science, a lock or mutex (from mutual exclusion) is a synchronization primitive: a mechanism that enforces limits on access to a resource when there are many threads of execution. A lock is designed to enforce a mutual exclusion concurrency control policy, and with a variety of possible methods there exists multiple unique implementations for different applications. (en) Un verrou informatique permet de s'assurer qu'une seule personne, ou un seul processus accède à une ressource à un instant donné. Ceci est souvent utilisé dans le domaine des accès à des fichiers sur des systèmes d'exploitation multi-utilisateur, car si deux programmes modifient un même fichier au même moment, le risque est de : * provoquer des erreurs dans un des deux programmes, voire dans les deux ; * laisser le fichier en fin de traitement dans une complète incohérence ; * endommager le fichier manipulé. Un verrou peut être posé pour protéger un accès en lecture et permettra à plusieurs processus de lire, mais à aucun d'écrire. On dit alors que c'est un verrou partagé. Un verrou est dit exclusif lorsqu'il interdit toute écriture et toute lecture en dehors du processus qui l'a posé. La granularité d'un verrou constitue l'étendue des éléments qu'il protège. Par exemple dans les bases de données, un verrou peut être posé sur une ligne, un lot de ligne, une table... (fr) In informatica un lock (inglese per «blocco») è un meccanismo di sincronizzazione per limitare l'accesso ad una risorsa condivisa in un ambiente multitasking ad un solo thread o ad un solo tipo di thread alla volta. Concettualmente un lock è un oggetto di cui un thread deve venire in possesso prima di poter procedere all'esecuzione di una sezione protetta di un programma. Ci sono regole prestabilite che dispongono il possesso di un lock. Nel caso più elementare il lock può essere assegnato ad un solo thread; in altri casi il possesso può coinvolgere in modo esclusivo più thread di lettura oppure un solo thread di scrittura (lock read/write). In ogni caso, se un thread non può acquisire immediatamente il lock deve aspettare che questo diventi libero oppure abbandonare la sezione protetta. Le implementazioni dei mutex nei monitor di sincronizzazione fanno generalmente uso di lock. (it) 컴퓨터 과학에서 락(lock) 또는 뮤텍스(mutex, 상호 배제에서)는 여러 스레드를 실행하는 환경에서 자원에 대한 접근에 제한을 강제하기 위한 동기화 매커니즘이다. 잠금이라고도 한다. 락은 상호 배제 동시성 제어 정책을 강제하기 위해 설계된다. (ko) 計算機科学におけるロック (英: lock) とは、計算機システム内に複数の動作主体（プロセスやスレッドなど）のある環境で、データやデバイスなどの計算資源（リソース）へのアクセス制限を課す同期機構。ロックは並行性制御ポリシーを実施する手法のひとつである。アクセス制限を課す動作を「ロックする」、「ロックを取得する」などと表現する。また対義語として、制限を解除することをアンロック（英: unlock）という（ロック解放、ロック解除とも）。 (ja) Blokada (ang. lock) – mechanizm służący do zapobiegania konfliktom w dostępie do zasobów w środowiskach wielozadaniowych. Zadanie (proces lub wątek) przed uzyskaniem dostępu do musi uzyskać dla siebie blokadę tego zasobu. Po zakończeniu wykorzystywania zasobu, zadanie musi blokadę zwolnić, aby udostępnić zasób innym zadaniom. Podział blokad odzwierciedla podział zasobów na prywatne, wyłączne i dzielone: * W przypadku zasobów prywatnych nie jest konieczny mechanizm blokad, gdyż zasób jest trwale powiązany z zadaniem. * Uzyskanie blokady wyłącznej uniemożliwia innym zadaniom dostęp do niej na czas jej posiadania. * Blokady dzielone mogą być w jednej chwili uzyskane przez więcej niż jedno zadanie. Ilość zadań, które mogą uzyskać dostęp do blokady dzielonej, zależy od kodu programu i zwykle jest zależna od struktury danych lub urządzenia, z którym ta blokada jest związana. Zależnie od systemu blokady mogą być albo ściśle egzekwowane (mandatory locks), albo służą jedynie do informowania procesu o tym, że dostęp jest bezpieczny, i nie są wymuszane (advisory locks). Te pierwsze są powszechne w systemach baz danych, te drugie w systemach plików. Kluczowym mankamentem algorytmów większości blokad jest konieczność uzyskiwania i zwalniania ich przez program realizujący zadanie, więc zależy jedynie od programisty i jego kodu. Przy błędnym kodzie pojawiają się problemy takie jak zakleszczenie. (pl) 在计算机科学中，锁是在执行多线程时用于强行限制资源访问的同步机制，即用于在并发控制中保证对互斥要求的满足。 一般的鎖是建議鎖（advisory lock），每個線程在訪問對應資源前都需取得鎖的資訊，再根據資訊決定是否可以存取。若存取對應資訊，鎖的狀態會改變為鎖定，因此其他線程此時不會訪問該資源，當資源結束後，會恢復鎖的狀態，允許其他線程的訪問。我们日常使用的基本都是建议锁，它并不强制生效。这里的不强制生效的意思是，如果某一个进程对一个文件持有一把锁之后，其他进程仍然可以直接对文件进行各种操作的，比如open、read、write。只有当多个进程在操作文件前都去检查和对相关锁进行锁操作的时候，文件锁的规则才会生效。这就是一般建议锁的行为。 有些系統有強制鎖（mandatory lock），若有未授權的線程想要訪問鎖定的資料，在訪問時就會產生异常。强制锁试图实现一套内核级的锁操作。当有进程对某个文件上锁之后，其他进程即使不在操作文件之前检查锁，也会在open、read或write等文件操作时发生错误。内核将对有锁的文件在任何情况下的锁规则都生效，这就是强制锁的行为。由此可以理解，如果内核想要支持强制锁，将需要在内核实现open、read、write等系统调用内部进行支持。 (zh) Блокування (англ. lock, рос. блокировка) — один із механізмів синхронізації в інформатиці, що забезпечує ексклюзивний доступ до спільного ресурсу. (uk) В информатике, блокировка — механизм синхронизации, позволяющий обеспечить исключительный доступ к разделяемому ресурсу между несколькими потоками. Блокировки — это один из способов обеспечить политику . (ru) |
| dbo:wikiPageExternalLink | https://web.archive.org/web/20110620203242/http:/www.futurechips.org/tips-for-power-coders/parallel-programming-understanding-impact-critical-sections.html https://pkg.go.dev/sync |
| dbo:wikiPageID | 244593 (xsd:integer) |
| dbo:wikiPageLength | 26566 (xsd:nonNegativeInteger) |
| dbo:wikiPageRevisionID | 1083762167 (xsd:integer) |
| dbo:wikiPageWikiLink | dbr:Python_(programming_language) dbr:Ruby_(programming_language) dbr:Method_(computer_programming) dbr:Monitor_(synchronization) dbr:Priority_inheritance dbr:Resource_contention dbr:C++0x dbr:Deadlock dbr:Dekker's_algorithm dbr:Double-checked_locking dbr:Priority_inversion dbr:Power_cycling dbr:Spinlock dbr:Run_time_(program_lifecycle_phase) dbr:Rust_(programming_language) dbr:Non-blocking_synchronization dbr:Object_(computer_science) dbr:Go_(programming_language) dbr:Concurrency_control dbr:Concurrent_user dbr:Critical_section dbr:Application_programming_interface dbr:Livelock dbr:Lock-free_and_wait-free_algorithms dbr:Simon_Peyton_Jones dbr:Compare-and-swap dbr:Computer_science dbr:Function_composition_(computer_science) dbr:Atomic_operation dbr:Funnel_(Concurrent_computing) dbr:Peterson's_algorithm dbr:Priority_ceiling_protocol dbr:Semaphore_(programming) dbr:Synchronization_(computer_science) dbr:Mutual_exclusion dbr:C++ dbr:C++11 dbr:C_(programming_language) dbr:C_Sharp_(programming_language) dbr:Ada_(programming_language) dbr:Database_management_system dbr:Exception_handling dbr:Fetch-and-add dbr:Fortran dbc:Articles_with_example_C_Sharp_code dbr:PHP dbr:POSIX_Threads dbr:Granularity_(parallel_computing) dbr:Lock_convoy dbr:Haskell_(programming_language) dbr:Java_(programming_language) dbc:Concurrency_control dbc:Software_design_patterns dbr:Blocking_(computing) dbr:C11_(C_standard_revision) dbr:File_locking dbr:Encapsulation_(object-oriented_programming) dbr:Method_(computer_science) dbr:Microsoft_Windows dbr:Objective-C dbr:OpenMP dbr:Race_condition dbr:Read/write_lock_pattern dbr:Serializing_tokens dbr:Software_transactional_memory dbr:Two-phase_locking dbr:Visual_C++ dbr:Transactional_memory dbr:Lock_(database) dbr:Test-and-set dbr:Wait-for_graph dbr:VB.NET dbr:Fortran_(programming_language) dbr:Optimistic_locking dbr:Synchronization_primitive dbr:Atomic_(computer_science) dbr:Multiprocessor dbr:Thread_(computer_science) dbr:Uniprocessor dbr:Execution_(computers) dbr:X86_assembly dbr:Lock_strategy dbr:Uninterruptible_sequence |
| dbp:wikiPageUsesTemplate | dbt:Citation_needed dbt:Main_article dbt:Mono dbt:Not_a_typo dbt:Reflist dbt:See_also dbt:Short_description dbt:Design_Patterns_patterns |
| dct:subject | dbc:Articles_with_example_C_Sharp_code dbc:Concurrency_control dbc:Software_design_patterns |
| gold:hypernym | dbr:Mechanism |
| rdf:type | owl:Thing yago:WikicatOperatingSystems yago:WikicatSoftwareDesignPatterns yago:Abstraction100002137 yago:Code106355894 yago:CodingSystem106353757 yago:Cognition100023271 yago:Communication100033020 yago:Form105930736 yago:OperatingSystem106568134 yago:PsychologicalFeature100023100 yago:Writing106359877 yago:WrittenCommunication106349220 dbo:Organisation yago:Software106566077 yago:Structure105726345 |
| rdfs:comment | Zámek je v informatice označení synchronizačního primitiva pro zajištění výhradního přístupu k systémovým prostředkům (místo v operační paměti, vstupně-výstupní nebo jiný hardware připojený k počítači) ve víceúlohovém prostředí, kde tak brání souběhu. Zámky jsou používány jak v případě, že dochází k cyklickému přepínání mezi běžícími úlohami, tak při skutečně paralelním běhu úloh ve víceprocesorových systémech. Typické je použití v multithreadových programech, například v Javě. (cs) القفل مصطلح مستعمل في ميدان الحوسبة المتوازية، والقفل هو آلية تزامن لتأمين تطبيق قيود على الوصول إلى مورد في بيئة حيث يتم تنفيذ عدة خيوط. فيصبح الوصول مؤمن لطالب واحد في نفس الوقت. الأقفال أحد الطرق لإنفاذ سياسات مراقبة التزامن. كما أن الأقفال مستعمل أيضا في أنظمة التشغيل متعددة المستخدمين. (ar) Unter einem Lock oder Locking (englisch für Sperre oder Sperren) versteht man in der Informatik das Sperren des Zugriffs auf ein Betriebsmittel. Eine solche Sperre ermöglicht den exklusiven Zugriff eines Prozesses auf eine Ressource, d. h. mit der Garantie, dass kein anderer Prozess diese Ressource liest oder verändert, solange die Sperre besteht. Locking wird häufig bei Prozesssynchronisation sowie in Datei- und Datenbanksystemen verwendet, um atomare und konsistente Lese- und Schreibanforderungen zu gewährleisten. (de) In computer science, a lock or mutex (from mutual exclusion) is a synchronization primitive: a mechanism that enforces limits on access to a resource when there are many threads of execution. A lock is designed to enforce a mutual exclusion concurrency control policy, and with a variety of possible methods there exists multiple unique implementations for different applications. (en) 컴퓨터 과학에서 락(lock) 또는 뮤텍스(mutex, 상호 배제에서)는 여러 스레드를 실행하는 환경에서 자원에 대한 접근에 제한을 강제하기 위한 동기화 매커니즘이다. 잠금이라고도 한다. 락은 상호 배제 동시성 제어 정책을 강제하기 위해 설계된다. (ko) 計算機科学におけるロック (英: lock) とは、計算機システム内に複数の動作主体（プロセスやスレッドなど）のある環境で、データやデバイスなどの計算資源（リソース）へのアクセス制限を課す同期機構。ロックは並行性制御ポリシーを実施する手法のひとつである。アクセス制限を課す動作を「ロックする」、「ロックを取得する」などと表現する。また対義語として、制限を解除することをアンロック（英: unlock）という（ロック解放、ロック解除とも）。 (ja) 在计算机科学中，锁是在执行多线程时用于强行限制资源访问的同步机制，即用于在并发控制中保证对互斥要求的满足。 一般的鎖是建議鎖（advisory lock），每個線程在訪問對應資源前都需取得鎖的資訊，再根據資訊決定是否可以存取。若存取對應資訊，鎖的狀態會改變為鎖定，因此其他線程此時不會訪問該資源，當資源結束後，會恢復鎖的狀態，允許其他線程的訪問。我们日常使用的基本都是建议锁，它并不强制生效。这里的不强制生效的意思是，如果某一个进程对一个文件持有一把锁之后，其他进程仍然可以直接对文件进行各种操作的，比如open、read、write。只有当多个进程在操作文件前都去检查和对相关锁进行锁操作的时候，文件锁的规则才会生效。这就是一般建议锁的行为。 有些系統有強制鎖（mandatory lock），若有未授權的線程想要訪問鎖定的資料，在訪問時就會產生异常。强制锁试图实现一套内核级的锁操作。当有进程对某个文件上锁之后，其他进程即使不在操作文件之前检查锁，也会在open、read或write等文件操作时发生错误。内核将对有锁的文件在任何情况下的锁规则都生效，这就是强制锁的行为。由此可以理解，如果内核想要支持强制锁，将需要在内核实现open、read、write等系统调用内部进行支持。 (zh) Блокування (англ. lock, рос. блокировка) — один із механізмів синхронізації в інформатиці, що забезпечує ексклюзивний доступ до спільного ресурсу. (uk) В информатике, блокировка — механизм синхронизации, позволяющий обеспечить исключительный доступ к разделяемому ресурсу между несколькими потоками. Блокировки — это один из способов обеспечить политику . (ru) En ciències de la computació, els cadenats d'exclusió mútua o "locks" (anglès) són un mecanisme de sincronització que limita l'accés a un recurs compartit per diversos processos o fils en un ambient d'execució concurrent, permetent així l'exclusió mútua. En general hi ha un nombre de restriccions sobre els cadenats, encara que no són les mateixes en tots els sistemes. Aquestes són: * Només el propietari d'un cadenat pot desbloquejar * La readquisició d'un cadenat no està permesa (ca) En ciencias de la computación, los cierres de exclusión mutua, candados o mutex son un mecanismo de sincronización que limita el acceso a un recurso compartido por varios procesos o hilos en un ambiente de ejecución concurrente, permitiendo así la exclusión mutua. En general hay un número de restricciones sobre los cerrojos, aunque no son las mismas en todos los sistemas. Estas son: * Sólo el dueño de un cerrojo puede desbloquearlo * La readquisición de un cerrojo no está permitida (es) In informatica un lock (inglese per «blocco») è un meccanismo di sincronizzazione per limitare l'accesso ad una risorsa condivisa in un ambiente multitasking ad un solo thread o ad un solo tipo di thread alla volta. Le implementazioni dei mutex nei monitor di sincronizzazione fanno generalmente uso di lock. (it) Un verrou informatique permet de s'assurer qu'une seule personne, ou un seul processus accède à une ressource à un instant donné. Ceci est souvent utilisé dans le domaine des accès à des fichiers sur des systèmes d'exploitation multi-utilisateur, car si deux programmes modifient un même fichier au même moment, le risque est de : * provoquer des erreurs dans un des deux programmes, voire dans les deux ; * laisser le fichier en fin de traitement dans une complète incohérence ; * endommager le fichier manipulé. (fr) Blokada (ang. lock) – mechanizm służący do zapobiegania konfliktom w dostępie do zasobów w środowiskach wielozadaniowych. Zadanie (proces lub wątek) przed uzyskaniem dostępu do musi uzyskać dla siebie blokadę tego zasobu. Po zakończeniu wykorzystywania zasobu, zadanie musi blokadę zwolnić, aby udostępnić zasób innym zadaniom. Podział blokad odzwierciedla podział zasobów na prywatne, wyłączne i dzielone: (pl) |
| rdfs:label | قفل (حوسبة) (ar) Cadenat (informàtica) (ca) Zámek (informatika) (cs) Lock (de) Cierre de exclusión mutua (es) Verrou (informatique) (fr) Lock (it) ロック (計算機科学) (ja) Lock (computer science) (en) 락 (컴퓨터 과학) (ko) Blokada (informatyka) (pl) Блокировка (программирование) (ru) 锁 (计算机科学) (zh) Блокування (програмування) (uk) |
| rdfs:seeAlso | dbr:Barrier_(computer_science) |
| owl:sameAs | freebase:Lock (computer science) wikidata:Lock (computer science) dbpedia-ar:Lock (computer science) dbpedia-ca:Lock (computer science) dbpedia-cs:Lock (computer science) dbpedia-de:Lock (computer science) dbpedia-es:Lock (computer science) dbpedia-fa:Lock (computer science) dbpedia-fr:Lock (computer science) dbpedia-he:Lock (computer science) dbpedia-hu:Lock (computer science) dbpedia-it:Lock (computer science) dbpedia-ja:Lock (computer science) dbpedia-ko:Lock (computer science) http://lt.dbpedia.org/resource/Užraktas_(programavimas) dbpedia-pl:Lock (computer science) dbpedia-ru:Lock (computer science) dbpedia-uk:Lock (computer science) dbpedia-zh:Lock (computer science) https://global.dbpedia.org/id/RSRW yago-res:Lock (computer science) |
| prov:wasDerivedFrom | wikipedia-en:Lock_(computer_science)?oldid=1083762167&ns=0 |
| foaf:isPrimaryTopicOf | wikipedia-en:Lock_(computer_science) |
| is dbo:wikiPageDisambiguates of | dbr:Lock |
| is dbo:wikiPageRedirects of | dbr:Locking_(computer_science) dbr:Fine-grained_locking dbr:Atomic_lock dbr:Mandatory_lock dbr:Mutex dbr:Advisory_lock dbr:Lock_(computer) dbr:Lock_(software_engineering) dbr:Lock_contention dbr:Lock_pattern dbr:Lock_variable |
| is dbo:wikiPageWikiLink of | dbr:Python_(programming_language) dbr:Monitor_(synchronization) dbr:Network_File_System dbr:Memory_semantics_(computing) dbr:Priority_inheritance dbr:Processor_power_dissipation dbr:Berkeley_DB dbr:History_of_the_Actor_model dbr:Resource_contention dbr:Volatile_(computer_programming) dbr:Deadlock dbr:Double-checked_locking dbr:Interrupt_flag dbr:Thread_safety dbr:Substructural_type_system dbr:Spinlock dbr:Commitment_ordering dbr:SQLite dbr:SXM_(transactional_memory) dbr:Operational_transformation dbr:Clustered_file_system dbr:Global_serializability dbr:Moore's_law dbr:Concurrency_control dbr:Concurrent_hash_table dbr:Consensus_(computer_science) dbr:Copy-on-write dbr:Coroutine dbr:Critical_section dbr:The_Witness_(2016_video_game) dbr:Remote_File_Sharing dbr:Work_stealing dbr:Apache_Portable_Runtime dbr:Magic_SysRq_key dbr:Comparison_of_relational_database_management_systems dbr:Features_new_to_Windows_XP dbr:Kernel_(operating_system) dbr:Parallel_algorithm dbr:Parallel_computing dbr:Priority_queue dbr:Semaphore_(programming) dbr:Synchronization_(computer_science) dbr:System_resource dbr:Mutual_exclusion dbr:ThreadX dbr:WebDAV dbr:Linearizability dbr:Long-running_transaction dbr:Software_lockout dbr:ACID dbr:Access_Database_Engine dbr:Actor_model dbr:Darwin_(operating_system) dbr:DragonFly_BSD dbr:Erlang_(programming_language) dbr:Firebird_(database_server) dbr:PL/SQL dbr:Fork–join_model dbr:Global_interpreter_lock dbr:Glossary_of_operating_systems_terms dbr:Grand_Central_Dispatch dbr:History_monoid dbr:History_of_Python dbr:History_of_software_engineering dbr:Lock_convoy dbr:Read-copy-update dbr:Reference_(computer_science) dbr:Hamilton_C_shell dbr:Array_Based_Queuing_Locks dbr:Atom_(programming_language) dbr:ARX_(operating_system) dbr:Lease_(computer_science) dbr:SunOS dbr:TSS_(operating_system) dbr:Java_concurrency dbr:Java_memory_model dbr:Java_performance dbr:Thread_(computing) dbr:Real_time_Java dbr:Release_consistency dbr:Direct_Rendering_Infrastructure dbr:Busy_waiting dbr:Plumbr dbr:Software_construction dbr:Software_design_pattern dbr:File_locking dbr:Free_monoid dbr:Guarded_suspension dbr:Intel_Quark dbr:InterBase dbr:Microsoft_Access dbr:NaviServer dbr:OpenVZ dbr:REX_OS dbr:Readers–writer_lock dbr:Serializing_tokens dbr:Multiple_granularity_locking dbr:Server_Message_Block dbr:Software_transactional_memory dbr:Spl_(Unix) dbr:Shared_resource dbr:Snapshot_(computer_storage) dbr:Two-phase_locking dbr:Variable_(computer_science) dbr:Lock dbr:Locking_(computer_science) dbr:Thread-local_storage dbr:Serializability dbr:Pluribus dbr:WinFS dbr:Giant_lock dbr:New_and_delete_(C++) dbr:Synchronization_model dbr:Non-blocking_algorithm dbr:Non-lock_concurrency_control dbr:Scalability dbr:Resource_leak dbr:Parallel_programming_model dbr:Test_and_test-and-set dbr:Ticket_lock dbr:Fine-grained_locking dbr:Atomic_lock dbr:Mandatory_lock dbr:Mutex dbr:Advisory_lock dbr:Lock_(computer) dbr:Lock_(software_engineering) dbr:Lock_contention dbr:Lock_pattern dbr:Lock_variable |
| is foaf:primaryTopic of | wikipedia-en:Lock_(computer_science) |