Is Nokogiri thread-safe?

Nokogiri is a popular Ruby library for parsing HTML, XML, and other document types. It's built on top of libxml2 and libxslt, which are written in C. Thread safety in libraries like Nokogiri is an important consideration, especially in multi-threaded environments like web servers.

Nokogiri itself is generally considered thread-safe for parsing and searching documents. This means that you can safely create and use Nokogiri objects in different threads without corrupting the state of those objects. This is possible because the parsing of documents is usually stateless and each document is independent of others.

However, there are some caveats to consider:

1. Global Configuration: If you change any global configurations of Nokogiri or the underlying libraries (libxml2 and libxslt), it could affect other threads. You should avoid modifying global state once threads are in use.

2. Document Mutation: If you are modifying a document (adding/removing nodes, changing attributes, etc.), it is not safe to do this from multiple threads simultaneously. You would need to use appropriate thread synchronization mechanisms like Mutexes to ensure that document mutations are thread-safe.

3. Native Extensions: Since Nokogiri relies on native extensions, the thread safety also depends on the underlying C libraries. While libxml2 and libxslt are generally stable and robust, they may have their own thread safety considerations.

As a best practice, when using Nokogiri in a multi-threaded Ruby program, you should:

• Avoid modifying global library settings or ensure that any modifications are done before spawning threads.
• Treat Nokogiri documents as immutable once they are shared between threads, or use synchronization around any code that modifies the document.

Here's an example of safely using Nokogiri in a multi-threaded Ruby application:

require 'nokogiri'
require 'open-uri'
require 'thread'

urls = ['http://example.com', 'http://example.org', 'http://example.net']
mutex = Mutex.new
documents = []

threads = urls.map do |url|
  Thread.new do
    document = Nokogiri::HTML(URI.open(url))
    mutex.synchronize do
      documents << document
    end
  end
end

threads.each(&:join)

# Now you can safely work with the documents array
documents.each do |doc|
  puts doc.at('title').text
end

In this example, threads are used to fetch and parse HTML documents concurrently. We use a Mutex to synchronize access to the shared documents array, ensuring that only one thread can modify it at a time.

In conclusion, while Nokogiri is thread-safe for many operations, you need to be cautious with global configurations and document mutations to ensure a truly thread-safe application. When in doubt, refer to the official Nokogiri documentation and the libxml2/libxslt documentation for the most up-to-date information on thread safety.