Segue abaixo o mesmo código utilizando multiprocessing em vez de threading. Foram realizadas as adaptações necessárias para o funcionamento em processos separados, mantendo a mesma lógica de filas e estrutura principal:

python
import json
from urllib.parse import urljoin
import time
import undetected_chromedriver as uc
from selenium.common.exceptions import WebDriverException, NoSuchElementException
from selenium.webdriver.common.by import By
import os
from bs4 import BeautifulSoup

# Biblioteca de multiprocessing
from multiprocessing import Process, Queue, current_process
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Nome do arquivo JSON de saída
JSON_FILENAME = "extracted_data.json"

# Cada processo terá seu próprio driver (variável global por processo)
driver = None

def get_driver():
    """
    Inicializa o `undetected_chromedriver` para cada processo se ainda não houver um driver.
    """
    global driver
    if driver is None:
        options = uc.ChromeOptions()
        # Configurações do driver
        options.add_argument('--headless=new')
        options.add_argument('window-size=1920,1080')
        options.add_argument("--disable-gpu")
        options.add_argument('--ignore-certificate-errors')  # Apenas se enfrentar problemas de SSL
        
        # Desabilita imagens no Chrome para acelerar o carregamento da página
        chrome_prefs = {}
        options.experimental_options["prefs"] = chrome_prefs
        chrome_prefs["profile.default_content_settings"] = {"images": 2}
        chrome_prefs["profile.managed_default_content_settings.images"] = 2
        
        # Inicializa o driver com as opções, use_subprocess=True e timeout aumentado
        driver_kwargs = {'timeout': 600}
        driver = uc.Chrome(options=options, use_subprocess=True, **driver_kwargs)
    return driver

def close_driver():
    """
    Fecha o driver Selenium para o processo atual.
    """
    global driver
    if driver is not None:
        try:
            driver.quit()
        except:
            pass
        driver = None

def fetch_page_selenium(url, retries=3, backoff_factor=1.5):
    """
    Usa o Selenium para carregar a URL e retorna o driver.
    """
    drv = get_driver()
    timeout = 600  # Timeout aumentado para páginas grandes
    drv.set_page_load_timeout(timeout)
    
    for attempt in range(retries):
        try:
            print(f"[{current_process().name}] Tentativa {attempt+1} de acessar {url}")
            drv.get(url)
            # Aguarda a página carregar totalmente ou pelo menos os elementos necessários
            WebDriverWait(drv, 10).until(
                EC.presence_of_element_located((By.ID, "firstHeading"))
            )
            return drv
        except WebDriverException as e:
            print(f"[{current_process().name}] Erro ao acessar {url}: {e}")
            if attempt < retries - 1:
                wait_time = backoff_factor ** attempt
                print(f"[{current_process().name}] Tentando novamente em {wait_time:.1f} segundos...")
                time.sleep(wait_time)
            else:
                print(f"[{current_process().name}] Falha ao acessar {url} após {retries} tentativas.")
                raise

def get_all_page_links(links_queue):
    """
    Extrai todos os links das páginas a partir da página 'Special:AllPages' usando Selenium.
    Coloca os links na `links_queue` à medida que são encontrados.
    Ao final, insere "DONE" na fila para indicar fim.
    """
    print(f"[{current_process().name}] Iniciando extração de links.")
    
    base_url = "https://oldschool.runescape.wiki/"
    all_pages_url = urljoin(base_url, "w/Special:AllPages")
    drv = get_driver()
    drv.get(all_pages_url)
    total_pages_found = 0
    
    while True:
        print(f"[{current_process().name}] Extraindo links da página: {all_pages_url}")
        # Aguarda a página carregar
        try:
            WebDriverWait(drv, 10).until(
                EC.presence_of_element_located((By.CLASS_NAME, 'mw-allpages-body'))
            )
            content_div = drv.find_element(By.CLASS_NAME, 'mw-allpages-body')
            a_elements = content_div.find_elements(By.TAG_NAME, 'a')
            for a in a_elements:
                href = a.get_attribute('href')
                if href.startswith(base_url + 'w/') and not href.startswith(base_url + 'w/Special:'):
                    links_queue.put(href)
                    total_pages_found += 1
        except Exception as e:
            print(f"[{current_process().name}] Incapaz de encontrar o conteúdo da página: {e}")

        # Localiza o link 'Next page' usando PARTIAL_LINK_TEXT
        try:
            next_link = drv.find_element(By.PARTIAL_LINK_TEXT, 'Next page')
            if next_link:
                all_pages_url = next_link.get_attribute('href')
                drv.get(all_pages_url)
            else:
                break  # Nenhum link 'Next page' encontrado
        except NoSuchElementException:
            print(f"[{current_process().name}] Nenhum link 'Next page' encontrado.")
            break
        except Exception as e:
            print(f"[{current_process().name}] Erro ao encontrar o link 'Next page': {e}")
            break

    print(f"[{current_process().name}] Total de páginas encontradas: {total_pages_found}")
    # Sinaliza que não há mais links
    links_queue.put("DONE")
    
    close_driver()
    print(f"[{current_process().name}] Extração de links concluída e driver fechado.")

def parse_page(url):
    """
    Extrai informações detalhadas e estruturadas de uma página usando Selenium e BeautifulSoup.
    """
    print(f"[{current_process().name}] Processando página: {url}")
    drv = fetch_page_selenium(url)
    
    # Obter o HTML da página renderizada
    html = drv.page_source
    soup = BeautifulSoup(html, 'html.parser')
    
    # Extrair o título
    try:
        title_elem = soup.find(id='firstHeading')
        title = title_elem.text.strip()
    except Exception as e:
        print(f"[{current_process().name}] Incapaz de encontrar o título para {url}: {e}")
        title = ''
    
    # Extrair dados da infobox
    infobox_data = {}
    try:
        infobox = soup.find('table', {'class': lambda x: x and 'infobox' in x})
        if infobox:
            for tr in infobox.find_all('tr'):
                if tr.th and tr.td:
                    key = tr.th.get_text(strip=True)
                    value = tr.td.get_text(strip=True)
                    infobox_data[key] = value
    except Exception as e:
        print(f"[{current_process().name}] Incapaz de extrair infobox para {url}: {e}")
    
    # Extrair seções e conteúdo
    content_sections = {}
    try:
        content_div = soup.find('div', {'class': 'mw-parser-output'})
        if content_div:
            current_section = ''
            for element in content_div.children:
                if element.name in ['h2', 'h3', 'h4']:
                    # Extrair o título da seção
                    section_title = element.get_text(strip=True)
                    section_title = section_title.replace('[editar]', '').strip()
                    current_section = section_title
                    content_sections[current_section] = ''
                elif element.name == 'p':
                    # Adicionar o texto ao conteúdo da seção atual
                    text = element.get_text(strip=True)
                    if current_section:
                        content_sections[current_section] += text + '\n'
                    else:
                        if 'Introduction' in content_sections:
                            content_sections['Introduction'] += text + '\n'
                        else:
                            content_sections['Introduction'] = text + '\n'
                elif element.name == 'ul':
                    # Listas não ordenadas
                    items = [li.get_text(strip=True) for li in element.find_all('li')]
                    if current_section:
                        content_sections[current_section] += '\n'.join(items) + '\n'
                elif element.name == 'table':
                    # Extrair tabelas como listas de dicionários
                    table_data = []
                    headers = []
                    rows = element.find_all('tr')
                    header_row = element.find('tr')
                    if header_row:
                        header_cells = header_row.find_all(['th', 'td'])
                        headers = [cell.get_text(strip=True) for cell in header_cells]
                    for row in rows[1:]:  # Pular o cabeçalho
                        cells = row.find_all(['th', 'td'])
                        if len(cells) == len(headers):
                            row_data = {
                                headers[i]: cells[i].get_text(strip=True)
                                for i in range(len(headers))
                            }
                            table_data.append(row_data)
                        else:
                            # Caso as células não correspondam aos cabeçalhos
                            row_data = [cell.get_text(strip=True) for cell in cells]
                            table_data.append(row_data)
                    if current_section:
                        content_sections[current_section + ' - Tabela'] = table_data
    except Exception as e:
        print(f"[{current_process().name}] Incapaz de extrair conteúdo para {url}: {e}")
    
    # Montar os dados da página
    page_data = {
        'url': url,
        'title': title,
        'infobox': infobox_data,
        'sections': content_sections
    }
    return page_data

def page_worker(worker_id, links_queue, data_queue):
    """
    Processo responsável por processar as páginas e colocar os dados na data_queue.
    """
    print(f"[Worker {worker_id}] Iniciando.")
    while True:
        url = links_queue.get()
        if url == "DONE":
            # Recoloca "DONE" para que os demais workers também possam encerrar
            links_queue.put("DONE")
            break
        else:
            try:
                page_data = parse_page(url)
                data_queue.put(page_data)
                print(f"[Worker {worker_id}] Página processada: {page_data.get('title')}")
            except Exception as e:
                print(f"[Worker {worker_id}] Erro ao processar {url}: {e}")
            finally:
                links_queue.task_done()
    close_driver()
    print(f"[Worker {worker_id}] Finalizando e driver fechado.")

def writer_process(filename, data_queue):
    """
    Processo responsável por escrever dados no arquivo JSON em tempo real.
    """
    print(f"[Writer] Iniciando escrita em {filename}")
    is_first_item = True
    processed_pages = 0
    
    with open(filename, "w", encoding="utf-8") as f:
        f.write("[\n")  # Inicia o array JSON
        
        while True:
            data = data_queue.get()
            if data == "DONE":
                break
            if is_first_item:
                json.dump(data, f, ensure_ascii=False, indent=4)
                is_first_item = False
            else:
                f.write(",\n")
                json.dump(data, f, ensure_ascii=False, indent=4)
            f.flush()
            processed_pages += 1
            print(f"[Writer] Dados da página '{data.get('title')}' salvos. Total processadas: {processed_pages}")
        
        f.write("\n]")  # Fecha o array JSON
    
    print(f"[Writer] Escrita concluída no arquivo '{filename}'.")

def initialize_json_file(filename=JSON_FILENAME):
    """
    Inicializa o arquivo JSON. Remove-o se já existir.
    """
    if os.path.exists(filename):
        os.remove(filename)
        print(f"Arquivo existente '{filename}' removido para iniciar nova extração.")
    else:
        print(f"Arquivo '{filename}' não existe. Será criado durante a extração.")

def main():
    # Inicializa o arquivo JSON
    initialize_json_file()
    
    # Cria as filas de comunicação entre processos
    links_queue = Queue()
    data_queue = Queue()
    
    # Inicia o processo escritor
    writer = Process(target=writer_process, args=(JSON_FILENAME, data_queue))
    writer.start()
    
    # Inicia o processo de extração de links
    link_proc = Process(target=get_all_page_links, args=(links_queue,))
    link_proc.start()
    
    # Inicia processos de trabalho para processar as páginas
    num_workers = 5
    workers = []
    for i in range(num_workers):
        p = Process(target=page_worker, args=(i, links_queue, data_queue))
        p.start()
        workers.append(p)
    
    # Aguarda a extração de links finalizar
    link_proc.join()
    print("Extração de links concluída.")
    
    # Aguarda todos os links serem processados (Queue.join() em multiprocessing não funciona
    # exatamente como em threading; aqui usaremos outra abordagem se necessário,
    # mas vamos colocar 'DONE' para encerrar os workers).
    
    # Quando link_proc termina, sabemos que já colocou "DONE" na fila de links,
    # e os workers vão finalizar ao ler esse "DONE".
    for w in workers:
        w.join()
    print("Todos os workers foram finalizados.")
    
    # Sinaliza para o processo de escrita que não há mais dados
    data_queue.put("DONE")
    
    # Aguarda o processo de escrita finalizar
    writer.join()
    print("Processo de escrita finalizado.")
    print("Extração concluída com sucesso.")

if __name__ == "__main__":
    main()

O que foi alterado em relação ao código original:

1. Import de multiprocessing:

   • from multiprocessing import Process, Queue substitui o uso de threads.

2. Substituição de threading.Thread por multiprocessing.Process:

   • As funções que eram executadas em threads agora rodam em processos separados (link extractor, workers e writer).

3. Remoção do thread_local:

   • Cada processo passa a ter seu próprio driver global. Assim, não há mais thread_local.driver.
   • Agora existe uma variável global driver = None que é instanciada pela primeira vez que cada processo chama get_driver().

4. Fechamento do driver em cada processo:

   • A função close_driver() fecha o driver global de cada processo ao encerrar.

5. Controlando fim das filas:

   • Quando o processo de extração de links termina, coloca "DONE" na fila de links. Cada worker, ao encontrar "DONE", a recoloca na fila para permitir que os demais workers também encerrem.

6. Writer Process:

   • O processo de escrita (writer_process) ficou responsável por abrir o arquivo JSON e escrever os dados enviados na data_queue, fechando-o ao receber "DONE".

7. Uso de if __name__ == "__main__"::

   • Necessário em Windows para evitar problemas de spawn recursivo de processos.
   • Garante também melhor legibilidade da inicialização.

Com estas mudanças, o script passa a usar multiprocessing para distribuir as tarefas entre processos, em vez de threading. As filas (Queue) possibilitam a comunicação entre esses processos de forma segura.

Análise do problema

O erro ocorre porque, ao migrar de threading para multiprocessing, foi mantido o uso de métodos (task_done() e join()) que fazem parte de queue.Queue (utilizado em threading), mas não existem em multiprocessing.Queue. Eis o trecho do stack trace que evidencia o problema:

AttributeError: 'Queue' object has no attribute 'task_done'

No código original com threads, você provavelmente tinha algo como:

python
links_queue.task_done()
links_queue.join()

ou similares. Essas chamadas só fazem sentido em queue.Queue (do threading). Em multiprocessing.Queue, tais métodos não existem.

---

Duas soluções possíveis

1. Remover as chamadas a task_done() e join()

Se não for estritamente necessário ter o mesmo controle de finalização de tarefas que o Queue.join() provê em threading, a maneira mais simples é remover qualquer chamada a:

python
links_queue.task_done()
links_queue.join()

E, para sabermos que todos os processos terminaram, usamos apenas:

• Process.join() em cada worker para aguardar sua finalização.
• Um valor especial na queue (como "DONE") para sinalizar o fim dos dados.

Por exemplo:

python
# Envia "DONE" para sinalizar aos workers que devem encerrar
links_queue.put("DONE")

# Aguarda cada processo worker encerrar
for w in workers:
    w.join()

Isso já garante que todos os processos terminaram, sem usar task_done().

2. Usar JoinableQueue no lugar de Queue

Se você quiser manter a lógica de contar quando todas as tarefas foram finalizadas (como no modo threading com task_done() e join()), pode-se trocar para multiprocessing.JoinableQueue, que implementa métodos equivalentes:

python
from multiprocessing import Process, JoinableQueue

# Em vez de Queue
links_queue = JoinableQueue()

...

# Nos workers, ao terminar de processar o item:
links_queue.task_done()

...

# Em algum lugar no main, depois de criar os workers:
links_queue.join()  # Aguarda esvaziar a fila

Contudo, vale ressaltar que o uso de JoinableQueue em multiprocessing pode envolver algumas sutilezas a mais do que em threading, especialmente em Windows, dependendo do volume de dados trafegados.

---

Resumo da Correção

Portanto, para resolver o problema "AttributeError: 'Queue' object has no attribute 'task_done'":

• Remova (ou comente) as linhas com queue.task_done() e queue.join() se estiver usando multiprocessing.Queue(), pois elas não existem nessa classe.

  python
  # links_queue.task_done()    # -> Remover
  # links_queue.join()         # -> Remover

  e controle o fim do processamento usando:

  python
  links_queue.put("DONE")
  for w in workers:
      w.join()

• Ou utilize JoinableQueue em vez de Queue caso seja fundamental manter a semântica de “trabalhos pendentes” (igual ao task_done() e join() do queue.Queue em threading). Nesse caso:

  python
  from multiprocessing import Process, JoinableQueue
  
  links_queue = JoinableQueue()
  
  ...
  
  def page_worker(...):
      ...
      links_queue.task_done()
  
  ...
  
  # depois de criar os workers, lá no main
  links_queue.join()  # Espera a fila ficar vazia

Usando um desses ajustes, o erro referente ao task_done() deixará de ocorrer e seu código passará a funcionar corretamente em multiprocessing.

Segue abaixo o código completo com uso de multiprocessing e correção do erro causado pelo uso de task_done() (que não existe em multiprocessing.Queue). A solução adotada foi remover as chamadas a task_done() e join() específicas de queue.Queue, mantendo o controle de finalização pela espera (join) dos processos.

python
import json
from urllib.parse import urljoin
import time
import undetected_chromedriver as uc
from selenium.common.exceptions import WebDriverException, NoSuchElementException
from selenium.webdriver.common.by import By
import os
from bs4 import BeautifulSoup

# Biblioteca de multiprocessing
from multiprocessing import Process, Queue, current_process
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Nome do arquivo JSON de saída
JSON_FILENAME = "extracted_data.json"

# Cada processo terá seu próprio driver (variável global por processo)
driver = None

def get_driver():
    """
    Inicializa o `undetected_chromedriver` para cada processo se ainda não houver um driver.
    """
    global driver
    if driver is None:
        options = uc.ChromeOptions()
        # Configurações do driver
        options.add_argument('--headless=new')
        options.add_argument('window-size=1920,1080')
        options.add_argument("--disable-gpu")
        options.add_argument('--ignore-certificate-errors')  # Apenas se enfrentar problemas de SSL
        
        # Desabilita imagens no Chrome para acelerar o carregamento da página
        chrome_prefs = {}
        options.experimental_options["prefs"] = chrome_prefs
        chrome_prefs["profile.default_content_settings"] = {"images": 2}
        chrome_prefs["profile.managed_default_content_settings.images"] = 2
        
        # Inicializa o driver com as opções, use_subprocess=True e timeout aumentado
        driver_kwargs = {'timeout': 600}
        driver = uc.Chrome(options=options, use_subprocess=True, **driver_kwargs)
    return driver

def close_driver():
    """
    Fecha o driver Selenium para o processo atual.
    """
    global driver
    if driver is not None:
        try:
            driver.quit()
        except:
            pass
        driver = None

def fetch_page_selenium(url, retries=3, backoff_factor=1.5):
    """
    Usa o Selenium para carregar a URL e retorna o driver.
    """
    drv = get_driver()
    timeout = 600  # Timeout aumentado para páginas grandes
    drv.set_page_load_timeout(timeout)
    
    for attempt in range(retries):
        try:
            print(f"[{current_process().name}] Tentativa {attempt+1} de acessar {url}")
            drv.get(url)
            # Aguarda a página carregar totalmente ou pelo menos os elementos necessários
            WebDriverWait(drv, 10).until(
                EC.presence_of_element_located((By.ID, "firstHeading"))
            )
            return drv
        except WebDriverException as e:
            print(f"[{current_process().name}] Erro ao acessar {url}: {e}")
            if attempt < retries - 1:
                wait_time = backoff_factor ** attempt
                print(f"[{current_process().name}] Tentando novamente em {wait_time:.1f} segundos...")
                time.sleep(wait_time)
            else:
                print(f"[{current_process().name}] Falha ao acessar {url} após {retries} tentativas.")
                raise

def get_all_page_links(links_queue):
    """
    Extrai todos os links das páginas a partir da página 'Special:AllPages' usando Selenium.
    Coloca os links na `links_queue` à medida que são encontrados.
    Ao final, insere "DONE" na fila para indicar fim.
    """
    print(f"[{current_process().name}] Iniciando extração de links.")
    
    base_url = "https://oldschool.runescape.wiki/"
    all_pages_url = urljoin(base_url, "w/Special:AllPages")
    drv = get_driver()
    drv.get(all_pages_url)
    total_pages_found = 0
    
    while True:
        print(f"[{current_process().name}] Extraindo links da página: {all_pages_url}")
        # Aguarda a página carregar
        try:
            WebDriverWait(drv, 10).until(
                EC.presence_of_element_located((By.CLASS_NAME, 'mw-allpages-body'))
            )
            content_div = drv.find_element(By.CLASS_NAME, 'mw-allpages-body')
            a_elements = content_div.find_elements(By.TAG_NAME, 'a')
            for a in a_elements:
                href = a.get_attribute('href')
                if href.startswith(base_url + 'w/') and not href.startswith(base_url + 'w/Special:'):
                    links_queue.put(href)
                    total_pages_found += 1
        except Exception as e:
            print(f"[{current_process().name}] Incapaz de encontrar o conteúdo da página: {e}")

        # Localiza o link 'Next page' usando PARTIAL_LINK_TEXT
        try:
            next_link = drv.find_element(By.PARTIAL_LINK_TEXT, 'Next page')
            if next_link:
                all_pages_url = next_link.get_attribute('href')
                drv.get(all_pages_url)
            else:
                break  # Nenhum link 'Next page' encontrado
        except NoSuchElementException:
            print(f"[{current_process().name}] Nenhum link 'Next page' encontrado.")
            break
        except Exception as e:
            print(f"[{current_process().name}] Erro ao encontrar o link 'Next page': {e}")
            break

    print(f"[{current_process().name}] Total de páginas encontradas: {total_pages_found}")
    # Sinaliza que não há mais links
    links_queue.put("DONE")
    
    close_driver()
    print(f"[{current_process().name}] Extração de links concluída e driver fechado.")

def parse_page(url):
    """
    Extrai informações detalhadas e estruturadas de uma página usando Selenium e BeautifulSoup.
    """
    print(f"[{current_process().name}] Processando página: {url}")
    drv = fetch_page_selenium(url)
    
    # Obter o HTML da página renderizada
    html = drv.page_source
    soup = BeautifulSoup(html, 'html.parser')
    
    # Extrair o título
    try:
        title_elem = soup.find(id='firstHeading')
        title = title_elem.text.strip()
    except Exception as e:
        print(f"[{current_process().name}] Incapaz de encontrar o título para {url}: {e}")
        title = ''
    
    # Extrair dados da infobox
    infobox_data = {}
    try:
        infobox = soup.find('table', {'class': lambda x: x and 'infobox' in x})
        if infobox:
            for tr in infobox.find_all('tr'):
                if tr.th and tr.td:
                    key = tr.th.get_text(strip=True)
                    value = tr.td.get_text(strip=True)
                    infobox_data[key] = value
    except Exception as e:
        print(f"[{current_process().name}] Incapaz de extrair infobox para {url}: {e}")
    
    # Extrair seções e conteúdo
    content_sections = {}
    try:
        content_div = soup.find('div', {'class': 'mw-parser-output'})
        if content_div:
            current_section = ''
            for element in content_div.children:
                if element.name in ['h2', 'h3', 'h4']:
                    # Extrair o título da seção
                    section_title = element.get_text(strip=True)
                    section_title = section_title.replace('[editar]', '').strip()
                    current_section = section_title
                    content_sections[current_section] = ''
                elif element.name == 'p':
                    # Adicionar o texto ao conteúdo da seção atual
                    text = element.get_text(strip=True)
                    if current_section:
                        content_sections[current_section] += text + '\n'
                    else:
                        if 'Introduction' in content_sections:
                            content_sections['Introduction'] += text + '\n'
                        else:
                            content_sections['Introduction'] = text + '\n'
                elif element.name == 'ul':
                    # Listas não ordenadas
                    items = [li.get_text(strip=True) for li in element.find_all('li')]
                    if current_section:
                        content_sections[current_section] += '\n'.join(items) + '\n'
                elif element.name == 'table':
                    # Extrair tabelas como listas de dicionários
                    table_data = []
                    headers = []
                    rows = element.find_all('tr')
                    header_row = element.find('tr')
                    if header_row:
                        header_cells = header_row.find_all(['th', 'td'])
                        headers = [cell.get_text(strip=True) for cell in header_cells]
                    for row in rows[1:]:  # Pular o cabeçalho
                        cells = row.find_all(['th', 'td'])
                        if len(cells) == len(headers):
                            row_data = {
                                headers[i]: cells[i].get_text(strip=True)
                                for i in range(len(headers))
                            }
                            table_data.append(row_data)
                        else:
                            # Caso as células não correspondam aos cabeçalhos
                            row_data = [cell.get_text(strip=True) for cell in cells]
                            table_data.append(row_data)
                    if current_section:
                        content_sections[current_section + ' - Tabela'] = table_data
    except Exception as e:
        print(f"[{current_process().name}] Incapaz de extrair conteúdo para {url}: {e}")
    
    # Montar os dados da página
    page_data = {
        'url': url,
        'title': title,
        'infobox': infobox_data,
        'sections': content_sections
    }
    return page_data

def page_worker(worker_id, links_queue, data_queue):
    """
    Processo responsável por processar as páginas e colocar os dados na data_queue.
    Removeu-se o uso de `task_done()`, pois `multiprocessing.Queue` não o suporta.
    """
    print(f"[Worker {worker_id}] Iniciando.")
    while True:
        url = links_queue.get()
        if url == "DONE":
            # Recoloca "DONE" para que os demais workers também possam encerrar
            links_queue.put("DONE")
            break
        else:
            try:
                page_data = parse_page(url)
                data_queue.put(page_data)
                print(f"[Worker {worker_id}] Página processada: {page_data.get('title')}")
            except Exception as e:
                print(f"[Worker {worker_id}] Erro ao processar {url}: {e}")
            # Remover o links_queue.task_done() pois não existe em multiprocessing.Queue
    close_driver()
    print(f"[Worker {worker_id}] Finalizando e driver fechado.")

def writer_process(filename, data_queue):
    """
    Processo responsável por escrever dados no arquivo JSON em tempo real.
    """
    print(f"[Writer] Iniciando escrita em {filename}")
    is_first_item = True
    processed_pages = 0
    
    with open(filename, "w", encoding="utf-8") as f:
        f.write("[\n")  # Inicia o array JSON
        
        while True:
            data = data_queue.get()
            if data == "DONE":
                break
            if is_first_item:
                json.dump(data, f, ensure_ascii=False, indent=4)
                is_first_item = False
            else:
                f.write(",\n")
                json.dump(data, f, ensure_ascii=False, indent=4)
            f.flush()
            processed_pages += 1
            print(f"[Writer] Dados da página '{data.get('title')}' salvos. Total processadas: {processed_pages}")
        
        f.write("\n]")  # Fecha o array JSON
    
    print(f"[Writer] Escrita concluída no arquivo '{filename}'.")

def initialize_json_file(filename=JSON_FILENAME):
    """
    Inicializa o arquivo JSON. Remove-o se já existir.
    """
    if os.path.exists(filename):
        os.remove(filename)
        print(f"Arquivo existente '{filename}' removido para iniciar nova extração.")
    else:
        print(f"Arquivo '{filename}' não existe. Será criado durante a extração.")

def main():
    # Inicializa o arquivo JSON
    initialize_json_file()
    
    # Cria as filas de comunicação entre processos
    links_queue = Queue()
    data_queue = Queue()
    
    # Inicia o processo escritor
    writer = Process(target=writer_process, args=(JSON_FILENAME, data_queue))
    writer.start()
    
    # Inicia o processo de extração de links
    link_proc = Process(target=get_all_page_links, args=(links_queue,))
    link_proc.start()
    
    # Inicia processos de trabalho para processar as páginas
    num_workers = 5
    workers = []
    for i in range(num_workers):
        p = Process(target=page_worker, args=(i, links_queue, data_queue))
        p.start()
        workers.append(p)
    
    # Aguarda a extração de links finalizar
    link_proc.join()
    print("Extração de links concluída.")
    
    # Aguarda todos os workers finalizarem
    for w in workers:
        w.join()
    print("Todos os workers foram finalizados.")
    
    # Sinaliza para o processo de escrita que não há mais dados
    data_queue.put("DONE")
    
    # Aguarda o processo de escrita finalizar
    writer.join()
    print("Processo de escrita finalizado.")
    print("Extração concluída com sucesso.")

if __name__ == "__main__":
    main()

O que foi alterado

1. Removidos os trechos links_queue.task_done() nos workers e links_queue.join() no main(), pois não existem em multiprocessing.Queue().
2. Mantidos os processos “worker”, “link extractor” e “writer” com join(), para garantir que o script aguarde corretamente o término de cada processo.
3. O fluxo de encerramento agora depende apenas de inserir "DONE" na fila de links (para encerrar os workers) e também de inserir "DONE" na fila de dados (para encerrar o processo de escrita).

Com essas mudanças, o erro de AttributeError: 'Queue' object has no attribute 'task_done' não ocorre mais, e o script funciona corretamente usando multiprocessing.

A seguir está uma versão do código com otimizações que podem melhorar o desempenho, especialmente no carregamento de páginas via Selenium. As principais mudanças foram:

1. Uso de pageLoadStrategy = 'eager':

   • O ChromeOptions permite definir pageLoadStrategy para 'eager', o que faz o Selenium retornar o controle assim que o documento estiver em estado "interactive", sem esperar todo o carregamento de recursos adicionais (imagens, etc.).
   • Isso ajuda a começar a extração mais cedo.

2. Diminuição do tempo de espera explícita (WebDriverWait) de 10 para 5 segundos.

   • Se a página que você está acessando carrega rápido, 5 segundos (ou até menos) pode ser suficiente na maioria dos casos.
   • Em sites mais lentos, você pode ajustar conforme necessário.

3. Bloqueio de imagens e possíveis extensões desnecessárias, para acelerar ainda mais o carregamento.

   • Já havia bloqueio de imagens no código original, mas adicionamos algumas outras flags que podem ajudar.

4. Redução do backoff de re-tentativa (caso falhe o carregamento) de 1.5 para algo mais agressivo, por exemplo 1.2, para não esperar tanto tempo entre as tentativas.

É importante lembrar que, ao diminuir WebDriverWait e usar eager, há maior probabilidade de encontrar elementos ainda não carregados. Para isso, garantimos que esperamos explicitamente apenas pelos elementos que de fato precisamos (ex.: mw-parser-output ou firstHeading).

A implementação abaixo inclui essas melhorias. Ajuste conforme necessário ao seu cenário:

python
import json
from urllib.parse import urljoin
import time
import undetected_chromedriver as uc
from selenium.common.exceptions import WebDriverException, NoSuchElementException
from selenium.webdriver.common.by import By
import os
from bs4 import BeautifulSoup

# Biblioteca de multiprocessing
from multiprocessing import Process, Queue, current_process
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Nome do arquivo JSON de saída
JSON_FILENAME = "extracted_data.json"

# Cada processo terá seu próprio driver (variável global por processo)
driver = None

def get_driver():
    """
    Inicializa o `undetected_chromedriver` para cada processo se ainda não houver um driver,
    com configurações otimizadas para carregamento mais rápido.
    """
    global driver
    if driver is None:
        options = uc.ChromeOptions()
        
        # Estratégia de carregamento 'eager' (não espera todos os recursos como imagens)
        options.page_load_strategy = 'eager'
        
        # Configurações gerais do driver
        options.add_argument('--headless=new')
        options.add_argument('window-size=1920,1080')
        options.add_argument("--disable-gpu")
        options.add_argument('--disable-extensions')  # Desativa extensões
        options.add_argument('--ignore-certificate-errors')  # Apenas se enfrentar problemas de SSL

        # Desabilita imagens no Chrome para acelerar o carregamento
        chrome_prefs = {}
        options.experimental_options["prefs"] = chrome_prefs
        chrome_prefs["profile.default_content_settings"] = {"images": 2}
        chrome_prefs["profile.managed_default_content_settings.images"] = 2
        
        # Inicializa o driver com as opções, use_subprocess=True e timeout aumentado
        driver_kwargs = {'timeout': 600}
        driver = uc.Chrome(options=options, use_subprocess=True, **driver_kwargs)
    return driver

def close_driver():
    """
    Fecha o driver Selenium para o processo atual.
    """
    global driver
    if driver is not None:
        try:
            driver.quit()
        except:
            pass
        driver = None

def fetch_page_selenium(url, retries=3, backoff_factor=1.2):
    """
    Usa o Selenium para carregar a URL e retorna o driver.
    - pageLoadStrategy='eager' permite que retorne sem esperar todo carregamento.
    - Retirado "presence_of_element_located((By.ID, 'firstHeading'))" e trocado por
      algo mais rápido, mas que garanta o conteúdo principal (ex: 'mw-parser-output').
    """
    drv = get_driver()

    # Reduzimos ligeiramente o timeout de carregamento total da página
    timeout = 60
    drv.set_page_load_timeout(timeout)
    
    for attempt in range(retries):
        try:
            print(f"[{current_process().name}] Tentativa {attempt+1} de acessar {url}")
            drv.get(url)
            # Aguarda apenas a presença do contêiner principal (mw-parser-output)
            # por um tempo menor: 5 segundos.
            WebDriverWait(drv, 5).until(
                EC.presence_of_element_located((By.CLASS_NAME, "mw-parser-output"))
            )
            return drv
        except WebDriverException as e:
            print(f"[{current_process().name}] Erro ao acessar {url}: {e}")
            if attempt < retries - 1:
                wait_time = (backoff_factor ** attempt)
                print(f"[{current_process().name}] Tentando novamente em {wait_time:.1f} segundos...")
                time.sleep(wait_time)
            else:
                print(f"[{current_process().name}] Falha ao acessar {url} após {retries} tentativas.")
                raise

def get_all_page_links(links_queue):
    """
    Extrai todos os links das páginas a partir da página 'Special:AllPages' usando Selenium.
    Coloca os links na `links_queue` à medida que são encontrados.
    Ao final, insere "DONE" na fila para indicar fim.
    """
    print(f"[{current_process().name}] Iniciando extração de links.")
    
    base_url = "https://oldschool.runescape.wiki/"
    all_pages_url = urljoin(base_url, "w/Special:AllPages")
    drv = get_driver()
    
    # page_load_strategy=eager deve deixar o Selenium retornar cedo,
    # mas vamos colocar uma espera curta para o elemento principal:
    try:
        drv.set_page_load_timeout(30)
        drv.get(all_pages_url)
        WebDriverWait(drv, 5).until(
            EC.presence_of_element_located((By.CLASS_NAME, 'mw-allpages-body'))
        )
    except Exception as e:
        print(f"[{current_process().name}] Erro inicial ao abrir Special:AllPages: {e}")
    
    total_pages_found = 0
    
    while True:
        print(f"[{current_process().name}] Extraindo links da página: {all_pages_url}")
        # Aguarda a página carregar minimamente
        try:
            WebDriverWait(drv, 5).until(
                EC.presence_of_element_located((By.CLASS_NAME, 'mw-allpages-body'))
            )
            content_div = drv.find_element(By.CLASS_NAME, 'mw-allpages-body')
            a_elements = content_div.find_elements(By.TAG_NAME, 'a')
            for a in a_elements:
                href = a.get_attribute('href')
                if href.startswith(base_url + 'w/') and not href.startswith(base_url + 'w/Special:'):
                    links_queue.put(href)
                    total_pages_found += 1
        except Exception as e:
            print(f"[{current_process().name}] Incapaz de encontrar o conteúdo da página: {e}")

        # Localiza o link 'Next page'
        try:
            next_link = drv.find_element(By.PARTIAL_LINK_TEXT, 'Next page')
            if next_link:
                all_pages_url = next_link.get_attribute('href')
                drv.get(all_pages_url)
            else:
                break  # Nenhum link 'Next page' encontrado
        except NoSuchElementException:
            print(f"[{current_process().name}] Nenhum link 'Next page' encontrado.")
            break
        except Exception as e:
            print(f"[{current_process().name}] Erro ao encontrar o link 'Next page': {e}")
            break

    print(f"[{current_process().name}] Total de páginas encontradas: {total_pages_found}")
    # Sinaliza que não há mais links
    links_queue.put("DONE")
    
    close_driver()
    print(f"[{current_process().name}] Extração de links concluída e driver fechado.")

def parse_page(url):
    """
    Extrai informações detalhadas e estruturadas de uma página usando Selenium e BeautifulSoup.
    Usa tempo de espera menor, apoiado em 'eager' e um seletor básico para a
    existência do conteúdo principal (mw-parser-output).
    """
    print(f"[{current_process().name}] Processando página: {url}")
    drv = fetch_page_selenium(url)
    
    # Obter o HTML da página renderizada
    html = drv.page_source
    soup = BeautifulSoup(html, 'html.parser')
    
    # Extrair o título
    try:
        title_elem = soup.find(id='firstHeading')
        title = title_elem.text.strip() if title_elem else ''
    except Exception as e:
        print(f"[{current_process().name}] Incapaz de encontrar o título para {url}: {e}")
        title = ''
    
    # Extrair dados da infobox
    infobox_data = {}
    try:
        infobox = soup.find('table', {'class': lambda x: x and 'infobox' in x})
        if infobox:
            for tr in infobox.find_all('tr'):
                if tr.th and tr.td:
                    key = tr.th.get_text(strip=True)
                    value = tr.td.get_text(strip=True)
                    infobox_data[key] = value
    except Exception as e:
        print(f"[{current_process().name}] Incapaz de extrair infobox para {url}: {e}")
    
    # Extrair seções e conteúdo
    content_sections = {}
    try:
        content_div = soup.find('div', {'class': 'mw-parser-output'})
        if content_div:
            current_section = ''
            for element in content_div.children:
                if element.name in ['h2', 'h3', 'h4']:
                    section_title = element.get_text(strip=True).replace('[editar]', '').strip()
                    current_section = section_title
                    content_sections[current_section] = ''
                elif element.name == 'p':
                    text = element.get_text(strip=True)
                    if current_section:
                        content_sections[current_section] += text + '\n'
                    else:
                        if 'Introduction' in content_sections:
                            content_sections['Introduction'] += text + '\n'
                        else:
                            content_sections['Introduction'] = text + '\n'
                elif element.name == 'ul':
                    items = [li.get_text(strip=True) for li in element.find_all('li')]
                    if current_section:
                        content_sections[current_section] += '\n'.join(items) + '\n'
                elif element.name == 'table':
                    table_data = []
                    headers = []
                    rows = element.find_all('tr')
                    header_row = element.find('tr')
                    if header_row:
                        header_cells = header_row.find_all(['th', 'td'])
                        headers = [cell.get_text(strip=True) for cell in header_cells]
                    for row in rows[1:]:
                        cells = row.find_all(['th', 'td'])
                        if len(cells) == len(headers):
                            row_data = {
                                headers[i]: cells[i].get_text(strip=True)
                                for i in range(len(headers))
                            }
                            table_data.append(row_data)
                        else:
                            row_data = [cell.get_text(strip=True) for cell in cells]
                            table_data.append(row_data)
                    if current_section:
                        content_sections[current_section + ' - Tabela'] = table_data
    except Exception as e:
        print(f"[{current_process().name}] Incapaz de extrair conteúdo para {url}: {e}")
    
    # Montar os dados da página
    page_data = {
        'url': url,
        'title': title,
        'infobox': infobox_data,
        'sections': content_sections
    }
    return page_data

def page_worker(worker_id, links_queue, data_queue):
    """
    Processo responsável por processar as páginas e colocar os dados na data_queue.
    """
    print(f"[Worker {worker_id}] Iniciando.")
    while True:
        url = links_queue.get()
        if url == "DONE":
            # Recoloca "DONE" para que os demais workers também possam encerrar
            links_queue.put("DONE")
            break
        else:
            try:
                page_data = parse_page(url)
                data_queue.put(page_data)
                print(f"[Worker {worker_id}] Página processada: {page_data.get('title')}")
            except Exception as e:
                print(f"[Worker {worker_id}] Erro ao processar {url}: {e}")
            # Não há uso de task_done() pois em multiprocessing.Queue não existe
    close_driver()
    print(f"[Worker {worker_id}] Finalizando e driver fechado.")

def writer_process(filename, data_queue):
    """
    Processo responsável por escrever dados no arquivo JSON em tempo real.
    """
    print(f"[Writer] Iniciando escrita em {filename}")
    is_first_item = True
    processed_pages = 0
    
    with open(filename, "w", encoding="utf-8") as f:
        f.write("[\n")  # Inicia o array JSON
        
        while True:
            data = data_queue.get()
            if data == "DONE":
                break
            if is_first_item:
                json.dump(data, f, ensure_ascii=False, indent=4)
                is_first_item = False
            else:
                f.write(",\n")
                json.dump(data, f, ensure_ascii=False, indent=4)
            f.flush()
            processed_pages += 1
            print(f"[Writer] Dados da página '{data.get('title')}' salvos. Total processadas: {processed_pages}")
        
        f.write("\n]")  # Fecha o array JSON
    
    print(f"[Writer] Escrita concluída no arquivo '{filename}'.")

def initialize_json_file(filename=JSON_FILENAME):
    """
    Inicializa o arquivo JSON. Remove-o se já existir.
    """
    if os.path.exists(filename):
        os.remove(filename)
        print(f"Arquivo existente '{filename}' removido para iniciar nova extração.")
    else:
        print(f"Arquivo '{filename}' não existe. Será criado durante a extração.")

def main():
    # Inicializa o arquivo JSON
    initialize_json_file()
    
    # Cria as filas de comunicação entre processos
    links_queue = Queue()
    data_queue = Queue()
    
    # Inicia o processo escritor
    writer = Process(target=writer_process, args=(JSON_FILENAME, data_queue))
    writer.start()
    
    # Inicia o processo de extração de links
    link_proc = Process(target=get_all_page_links, args=(links_queue,))
    link_proc.start()
    
    # Inicia processos de trabalho para processar as páginas
    num_workers = 5
    workers = []
    for i in range(num_workers):
        p = Process(target=page_worker, args=(i, links_queue, data_queue))
        p.start()
        workers.append(p)
    
    # Aguarda a extração de links finalizar
    link_proc.join()
    print("Extração de links concluída.")
    
    # Aguarda todos os workers finalizarem
    for w in workers:
        w.join()
    print("Todos os workers foram finalizados.")
    
    # Sinaliza para o processo de escrita que não há mais dados
    data_queue.put("DONE")
    
    # Aguarda o processo de escrita finalizar
    writer.join()
    print("Processo de escrita finalizado.")
    print("Extração concluída com sucesso.")

if __name__ == "__main__":


**Warning:**
The response is not complete, would not consume credits.