Thread safety
http://dbpedia.org/resource/Thread_safety an entity of type: Abstraction100002137
سلامة الخيوط (Thread safety) هو مفهوم يتم استخدامه في الحوسبة المتوازية، ويعني أن جزء معين من برنامج يمكن استدعائه بالتوازي دون أن يكون هناك تأثير سلبي على أي من الاستدعاءات. توفر نظم التشغيل تقنية مسماة بالخيوط، تسمح بتشغيل أجزاء من برنامج بالتوازي. في أحيان كثيرة يكون هناك ذاكرة مشتركة بين الخيوط لتبادل المعلومات فيما بينها. يجب تنظيم استخدامات هذه الذاكرة لتفادي الوصول لوضع فوضوي في الذاكرة يمنع بعض أجزاء البرنامج من أداء المهمات المنوطة بها. من الآليات المستخدمة لتحقيق ذلك: الأقفال واستبعاد التشارك والسيمافور.
rdf:langString
스레드 안전(thread 安全, 영어: thread safety)은 멀티 스레드 프로그래밍에서 일반적으로 어떤 함수나 변수, 혹은 객체가 여러 스레드로부터 동시에 접근이 이루어져도 프로그램의 실행에 문제가 없음을 뜻한다. 보다 엄밀하게는 하나의 함수가 한 스레드로부터 호출되어 실행 중일 때, 다른 스레드가 그 함수를 호출하여 동시에 함께 실행되더라도 각 스레드에서의 함수의 수행 결과가 올바로 나오는 것으로 정의한다.
rdf:langString
Багатопотокова безпека (англ. Thread safety) — це концепція комп'ютерного програмування в застосуванні до контексту багатониткових програм.Код є багатонитково-безпечним (англ. thread-safe), якщо він здатен правильно виконуватись з різних програмних ділянок та в різних нитях одночасно без побічних негативних наслідків.
rdf:langString
线程安全是程式設計中的术语，指某个函数、函数库在多執行緒环境中被调用时，能够正确地处理多个執行緒之间的公用變數，使程序功能正确完成。 假設有間銀行只有 1000 元，而兩個人同時提領 1000 元時就可能會拿到總計 2000 元的金額。為了避免這個問題，該間銀行提款時應該使用互斥鎖，即意味著針對同一個資源處理時，前一個人提領交易完成後才處理下一筆交易。但這種手法會使得效能降低。 一般来说，线程安全的函数应该为每个调用它的线程分配专门的空间，来储存需要单独保存的状态（如果需要的话），不依赖于“线程惯性”，把多个线程共享的变量正确对待（如，通知编译器该變數为“易失（volatile）”型，阻止其进行一些不恰当的优化），而且，线程安全的函数一般不应该修改全局对象。 很多C库代码（比如某些strtok的实现，它将“多次调用中需要保持不变的状态”储存在静态变量中，导致不恰当的共享）不是线程安全的，在多執行緒环境中调用这些函数时，要进行特别的预防措施，或者寻找别的替代方案。
rdf:langString
Threadsicherheit (englisch thread safety) ist eine Eigenschaft von Softwarekomponenten und hat eine wichtige Bedeutung in der Softwareentwicklung. Sie besagt, dass eine Komponente gleichzeitig von verschiedenen Programmbereichen mehrfach ausgeführt werden kann, ohne dass diese sich gegenseitig behindern. Ist der gleichzeitige Zugriff mehrerer Threads möglich, so bezeichnet man die Komponente auch als eintrittsinvariant oder reentrant.
rdf:langString
La seguridad en hilos es un concepto de programación aplicable en el contexto de los programas multihilos. Una pieza de código es segura en cuanto a los hilos si funciona correctamente durante la ejecución simultánea de múltiples hilos. En particular, debe satisfacer la necesidad de que múltiples hilos accedan a los mismos datos compartidos, y la necesidad de que una pieza compartida de datos sea accedida por solo un hilo en un momento dado.
rdf:langString
La thread safety d'un code (qu'on appelle alors « code thread-safe ») est la propriété de celui-ci associée au fait qu'il est capable de fonctionner correctement lorsqu'il est exécuté simultanément au sein du même espace d'adressage par plusieurs threads. Si cette propriété d’un code n’est pas importante dans le cadre d’une exécution mono-thread (où le code n'est exécuté qu'une seule fois à un instant donné), elle en devient essentielle dans le cadre de la programmation concurrente multi-thread (où l'exécution simultanée du code est recherchée pour améliorer les performances du programme).
rdf:langString
Thread safety is a computer programming concept applicable to multi-threaded code. Thread-safe code only manipulates shared data structures in a manner that ensures that all threads behave properly and fulfill their design specifications without unintended interaction. There are various strategies for making thread-safe data structures.
rdf:langString
Il concetto di thread safety (dall'inglese sicurezza dei thread), in programmazione, viene utilizzato, nell'ambito del multithreading, per indicare la caratteristica di una porzione di codice che si comporta in modo corretto nel caso di esecuzioni multiple da parte di più thread. In particolare è importante che i vari thread possano avere accesso alle stesse informazioni condivise, ma che queste siano accessibili solo da un thread alla volta.
rdf:langString
スレッドセーフ（英: thread-safe）は、マルチスレッドプログラミングにおける概念である。あるプログラムコードがスレッドセーフであるという場合、そのコードを複数のスレッドが同時並行的に実行しても問題が発生しないことを意味する。特に、ある共有データへの複数のスレッドによるアクセスがあるとき、一度に1つのスレッドのみがその共有データにアクセスするようにして安全性を確保しなければならない。スレッドセーフでないコードを同時並行的に実行すると、レースコンディション（競合状態）が発生し、未定義動作を引き起こす。場合によっては深刻なセキュリティホール（脆弱性）が引き起こされることもある。
rdf:langString
Bezpieczeństwo wątków w programowaniu współbieżnym jest pojęciem stosowanym w kontekście programów wielowątkowych.Fragmenty kodu są „wątkowo-bezpieczne” (ang. thread-safe), jeżeli funkcje wywoływane jednocześnie przez wiele wątków wykonują się prawidłowo.W szczególności musi być spełniony następujący warunek: współbieżne wątki mają dostęp do tych samych współdzielonych danych oraz dostęp do fragmentu współdzielonych danych jest możliwy dla dokładnie jednego wątku w danym czasie.
rdf:langString
Thread safety (segurança de fio de execução) é um conceito de programação de computadores aplicável no contexto de programas multi-thread. Um pedaço de código é dito thread-safe se ele apenas manipula estruturas de dados compartilhadas de uma forma que garanta uma execução segura através de várias threads ao mesmo tempo. Há várias estratégias para tornar estruturas de dados thread-safe.
rdf:langString
Потоковая безопасность (англ. thread-safety) — это концепция программирования, применимая к многопоточным программам. Код потокобезопасен, если он функционирует исправно при использовании его из нескольких потоков одновременно. В частности, он должен обеспечивать правильный доступ нескольких потоков к разделяемым данным. В общем случае потоковая безопасность достигается сложно. Но существует несколько источников выявления нарушений потоковой безопасности: Есть несколько способов достигнуть потоковой безопасности:
rdf:langString
rdf:langString
سلامة الخيوط
rdf:langString
Threadsicherheit
rdf:langString
Seguridad en hilos
rdf:langString
Thread safety
rdf:langString
Thread safety
rdf:langString
スレッドセーフ
rdf:langString
스레드 안전
rdf:langString
Bezpieczeństwo wątków
rdf:langString
Thread safety
rdf:langString
Thread safety
rdf:langString
Thread-safety
rdf:langString
线程安全
rdf:langString
Багатониткова безпека
xsd:integer
45634
xsd:integer
1077340390
rdf:langString
سلامة الخيوط (Thread safety) هو مفهوم يتم استخدامه في الحوسبة المتوازية، ويعني أن جزء معين من برنامج يمكن استدعائه بالتوازي دون أن يكون هناك تأثير سلبي على أي من الاستدعاءات. توفر نظم التشغيل تقنية مسماة بالخيوط، تسمح بتشغيل أجزاء من برنامج بالتوازي. في أحيان كثيرة يكون هناك ذاكرة مشتركة بين الخيوط لتبادل المعلومات فيما بينها. يجب تنظيم استخدامات هذه الذاكرة لتفادي الوصول لوضع فوضوي في الذاكرة يمنع بعض أجزاء البرنامج من أداء المهمات المنوطة بها. من الآليات المستخدمة لتحقيق ذلك: الأقفال واستبعاد التشارك والسيمافور.
rdf:langString
Threadsicherheit (englisch thread safety) ist eine Eigenschaft von Softwarekomponenten und hat eine wichtige Bedeutung in der Softwareentwicklung. Sie besagt, dass eine Komponente gleichzeitig von verschiedenen Programmbereichen mehrfach ausgeführt werden kann, ohne dass diese sich gegenseitig behindern. Teile eines Computerprogramms können zum selben Zeitpunkt mehrmals ausgeführt werden. Dabei handelt es sich oft um eine Komponente oder auch nur um eine Funktion des Programms. Zum Zweck der Mehrfachausführung bieten Betriebssysteme sogenannte Threads an. Jeder Thread arbeitet dabei unabhängig von den anderen diesen Programmteil ab. Häufig muss das Programm dabei gleichzeitig auf einen gemeinsamen Speicherbereich (Shared Memory) des Computers zugreifen. Änderungen der einzelnen Threads müssen koordiniert werden, um einen chaotischen Zustand des Speichers zu verhindern. Man spricht hier auch von Synchronisation. Zum Zweck der Threadsynchronisation existieren mehrere Konzepte, wie z. B. Locks (engl. für Sperre: Ein Thread sperrt einen Speicherbereich zur exklusiven Bearbeitung, andere Threads haben währenddessen keinen Zugriff auf diesen Speicherbereich, bis dieser wieder freigegeben wird), Mutexe und Semaphore. Ist der gleichzeitige Zugriff mehrerer Threads möglich, so bezeichnet man die Komponente auch als eintrittsinvariant oder reentrant.
rdf:langString
La seguridad en hilos es un concepto de programación aplicable en el contexto de los programas multihilos. Una pieza de código es segura en cuanto a los hilos si funciona correctamente durante la ejecución simultánea de múltiples hilos. En particular, debe satisfacer la necesidad de que múltiples hilos accedan a los mismos datos compartidos, y la necesidad de que una pieza compartida de datos sea accedida por solo un hilo en un momento dado. La seguridad en hilos es un desafío clave en la programación multihilos. Antes solo concernía al programador del sistema operativo pero desde los últimos 1990s ha llegado a ser un asunto común. En un programa multihilos, varios threads se ejecutan simultáneamente en un espacio de direcciones compartido. Cada hilo tiene acceso a virtualmente toda la memoria de cada uno de los otros threads. Así el flujo de control y la secuencia de los accesos a datos a menudo tienen poca relación de lo que sería razonable esperar mirando el texto del programa. Thread-safety es una propiedad necesaria para minimizar el comportamiento inesperado restableciendo algunas de las correspondencias entre el flujo de control actual y el texto del programa.
rdf:langString
La thread safety d'un code (qu'on appelle alors « code thread-safe ») est la propriété de celui-ci associée au fait qu'il est capable de fonctionner correctement lorsqu'il est exécuté simultanément au sein du même espace d'adressage par plusieurs threads. Si cette propriété d’un code n’est pas importante dans le cadre d’une exécution mono-thread (où le code n'est exécuté qu'une seule fois à un instant donné), elle en devient essentielle dans le cadre de la programmation concurrente multi-thread (où l'exécution simultanée du code est recherchée pour améliorer les performances du programme). Pour permettre l'utilisation dans le cadre de la programmation concurrente d'un code qui n'est pas intrinsèquement thread-safe, on peut le protéger par des structures d'exclusion mutuelle pour garantir sa thread safety d'un point de vue extérieur, ou recourir à une séparation des espaces d'adressage. L'exécution simultanée de code qui n'est pas thread-safe peut conduire à des bugs réputés difficiles à résoudre, appelés race conditions.
rdf:langString
Thread safety is a computer programming concept applicable to multi-threaded code. Thread-safe code only manipulates shared data structures in a manner that ensures that all threads behave properly and fulfill their design specifications without unintended interaction. There are various strategies for making thread-safe data structures. A program may execute code in several threads simultaneously in a shared address space where each of those threads has access to virtually all of the memory of every other thread. Thread safety is a property that allows code to run in multithreaded environments by re-establishing some of the correspondences between the actual flow of control and the text of the program, by means of synchronization.
rdf:langString
스레드 안전(thread 安全, 영어: thread safety)은 멀티 스레드 프로그래밍에서 일반적으로 어떤 함수나 변수, 혹은 객체가 여러 스레드로부터 동시에 접근이 이루어져도 프로그램의 실행에 문제가 없음을 뜻한다. 보다 엄밀하게는 하나의 함수가 한 스레드로부터 호출되어 실행 중일 때, 다른 스레드가 그 함수를 호출하여 동시에 함께 실행되더라도 각 스레드에서의 함수의 수행 결과가 올바로 나오는 것으로 정의한다.
rdf:langString
Il concetto di thread safety (dall'inglese sicurezza dei thread), in programmazione, viene utilizzato, nell'ambito del multithreading, per indicare la caratteristica di una porzione di codice che si comporta in modo corretto nel caso di esecuzioni multiple da parte di più thread. In particolare è importante che i vari thread possano avere accesso alle stesse informazioni condivise, ma che queste siano accessibili solo da un thread alla volta. Nel caso di un processo multithreaded, ovvero composto da più thread simultanei che accedono virtualmente agli stessi dati, la struttura di controllo e l'ordine di accesso ai dati stessi non rispettano completamente la sequenzialità del testo del programma, e questo rende possibili comportamenti inaspettati dovuti alla manipolazione non corretta dei dati. Si rende quindi necessario minimizzare la possibilità di errori cercando di ristabilire le corrispondenze tra il testo del programma e la struttura di controllo reale, tramite diverse tecniche di implementazione.
rdf:langString
スレッドセーフ（英: thread-safe）は、マルチスレッドプログラミングにおける概念である。あるプログラムコードがスレッドセーフであるという場合、そのコードを複数のスレッドが同時並行的に実行しても問題が発生しないことを意味する。特に、ある共有データへの複数のスレッドによるアクセスがあるとき、一度に1つのスレッドのみがその共有データにアクセスするようにして安全性を確保しなければならない。スレッドセーフでないコードを同時並行的に実行すると、レースコンディション（競合状態）が発生し、未定義動作を引き起こす。場合によっては深刻なセキュリティホール（脆弱性）が引き起こされることもある。 スレッドセーフはマルチスレッドプログラミングにおける重要な要素である。それは従来、オペレーティングシステムの開発者だけが考慮しなければならない問題だったが、1990年代後半には一般的な問題となった。マルチスレッドプログラムでは、複数のスレッドが同じアドレス空間内で同時に実行される。各スレッドのアクセスするメモリ領域が特に制限されることはなく、全スレッドが全アドレス空間にアクセスできる。従って、プログラムを見たときに予測される制御の流れやデータアクセスの順序は実際に実行時に起きることとかけ離れたものとなることが多い。これは「驚き最小の原則」に反している。スレッドセーフは実際の処理の流れとプログラムのソースコードの関連性を強化し、予期しない動作を最小にすることを指向した特性である。
rdf:langString
Bezpieczeństwo wątków w programowaniu współbieżnym jest pojęciem stosowanym w kontekście programów wielowątkowych.Fragmenty kodu są „wątkowo-bezpieczne” (ang. thread-safe), jeżeli funkcje wywoływane jednocześnie przez wiele wątków wykonują się prawidłowo.W szczególności musi być spełniony następujący warunek: współbieżne wątki mają dostęp do tych samych współdzielonych danych oraz dostęp do fragmentu współdzielonych danych jest możliwy dla dokładnie jednego wątku w danym czasie. Bezpieczeństwo wątków jest kluczowym wyzwaniem w programowaniu wielowątkowym. Było ono kiedyś stosowane głównie przez przedsiębiorstwa specjalizujące się w projektowaniu systemów operacyjnych, jednak od końca lat 90. XX wieku bezpieczeństwo wątków stało się częściej spotykanym zagadnieniem. W programie wielowątkowym kilka wątków wykonuje jednocześnie operacje we współdzielonej przestrzeni adresowej. W rzeczywistości każdy wątek ma dostęp do pamięci wszystkich pozostałych wątków.
rdf:langString
Thread safety (segurança de fio de execução) é um conceito de programação de computadores aplicável no contexto de programas multi-thread. Um pedaço de código é dito thread-safe se ele apenas manipula estruturas de dados compartilhadas de uma forma que garanta uma execução segura através de várias threads ao mesmo tempo. Há várias estratégias para tornar estruturas de dados thread-safe. Um desafio principal em programação multi-thread, a segurança de thread não era uma preocupação para a maioria dos desenvolvedores de aplicações até os anos de 1990 quando os sistemas operacionais começaram a expor múltiplas threads para a execução de código. Hoje um programa pode executar código em várias threads simultaneamente em um espaço de endereçamento compartilhado quando cada uma destas threads possuam acesso a virtualmente toda a memória de todas as outras threads. A segurança de thread é uma propriedade que permite que o código rode em ambientes multi-thread através do restabelecimento de algumas das correspondências entre o fluxo de controle real e o texto do programa, por meio de sincronização.
rdf:langString
Багатопотокова безпека (англ. Thread safety) — це концепція комп'ютерного програмування в застосуванні до контексту багатониткових програм.Код є багатонитково-безпечним (англ. thread-safe), якщо він здатен правильно виконуватись з різних програмних ділянок та в різних нитях одночасно без побічних негативних наслідків.
rdf:langString
Потоковая безопасность (англ. thread-safety) — это концепция программирования, применимая к многопоточным программам. Код потокобезопасен, если он функционирует исправно при использовании его из нескольких потоков одновременно. В частности, он должен обеспечивать правильный доступ нескольких потоков к разделяемым данным. В общем случае потоковая безопасность достигается сложно. Но существует несколько источников выявления нарушений потоковой безопасности:
* доступ к глобальным переменным или динамической памяти (куче);
* выделение/освобождение ресурсов, имеющих глобальные ограничения (файлы, процессы и др.);
* неявный доступ через ссылки и указатели;
* побочный эффект функций. Есть несколько способов достигнуть потоковой безопасности: РеентерабельностьНаписание кода в таком стиле, что он может быть частично выполнен одним потоком, затем другим, и продолжен первым. Это требует сохранения состояния в локальных переменных, обычно в стеке, вместо глобальных или статических переменных.ЛинеаризуемостьНаписание кода процедур (операций) таким образом, что результат любого их параллельного выполнения эквивалентен некоторому последовательному выполнению.
rdf:langString
线程安全是程式設計中的术语，指某个函数、函数库在多執行緒环境中被调用时，能够正确地处理多个執行緒之间的公用變數，使程序功能正确完成。 假設有間銀行只有 1000 元，而兩個人同時提領 1000 元時就可能會拿到總計 2000 元的金額。為了避免這個問題，該間銀行提款時應該使用互斥鎖，即意味著針對同一個資源處理時，前一個人提領交易完成後才處理下一筆交易。但這種手法會使得效能降低。 一般来说，线程安全的函数应该为每个调用它的线程分配专门的空间，来储存需要单独保存的状态（如果需要的话），不依赖于“线程惯性”，把多个线程共享的变量正确对待（如，通知编译器该變數为“易失（volatile）”型，阻止其进行一些不恰当的优化），而且，线程安全的函数一般不应该修改全局对象。 很多C库代码（比如某些strtok的实现，它将“多次调用中需要保持不变的状态”储存在静态变量中，导致不恰当的共享）不是线程安全的，在多執行緒环境中调用这些函数时，要进行特别的预防措施，或者寻找别的替代方案。
xsd:nonNegativeInteger
9442