python ограничить область видимости для import (или шаринг переменных между модулями)

у каждого потока была своя область видимости.

Ну так вся суть потоков - это общая область видимости. Возьми лучше многопроцессность, заодно и от GIL избавишься.

Мне надо именно на потоках сделать

Может у кого ещё есть идеи?

сделать shared dict с ключем-айди потока?

Думал об этом, но тут получается что потоки ломятся в один словарь и выходит не безопасно, начинается конкуренция и вылетать ошибки

Тупо всё в функции сувать (все переменные), в итоге на каждый чих мне надо портянку переменных сувать, код раздувается

Запихни их в объект.

Да я и так туда словарь прихаю раздутый, проблема в том что мне на каждый чих в каждой функции надо туда сюда в каждом месте втыкать на входе и выходе этот объект (я использовал словарь). Говнокод, ищется красивое рабочее решение

эээ, пример ошибки? каждый поток доступ к только своему ключу, а там еще один словарик: shared.setdefault(pid, {}).get("var", 0)

красивое решение - не делать централизированное хранилище и хранить все по месту, если данные все-равно не пересекаюстя

Блокировки?

Я не проверял это решение, идея была сделать так, «import shared» вставлять в a.py и в b.py, а внутри там сделать словарь и данные идентифицировать по ключу, имя которого - имя потока.

Потом выяснилось следующее: - Потоки я запускаю в режиме демона, и может быть так что одно и тоже имя потока сначала одно задание потока обслужило, затем пошло к следующему - то есть уже есть возня с этими именами, надо затирать переменные после использования - Когда один читает а другой поток в это время пишет - начинаются конфликты

И вот как это сделать? Условно говоря мне надо подать на входе числа от 1 до 100, затем сделать так чтобы каждый поток взял установил внутри себя переменной значение a=число и эту переменную «a» мне надо видеть из других импортированных файлов, чтобы не было пересечения между потоками как сейчас это происходит

ну значит другу схему именования, не имя потока а хеш какого-то объекта уникального для функционала

Не понял, поясните пожалуйста

threading.local() ?

Всё равно как-то геморойно смотрится, не могли бы вы пожалуйста вашу схему правильной архитектуры расписать? Вот на примере этой задачи: python ограничить область видимости для import (или шаринг переменных между модулями) (комментарий)

https://docs.python.org/3.3/library/threading.html#lock-objects

лучше уже все в одном потоке тогда сделать

ну имя потока это что-то что ты сам задаешь? а одни и те же потоки выполняют разный код, но разный код зависит от своих переменных? ну и используй hash(my_func) как ключ в словаре, это если my_func1 использует ключ 1, my_func2 ключ 2 и так далее. можно хоть объект пустой создавать в коде и его использовать: key = hash(object()).

не могли бы вы мысль развернуть пожалуйста?

я смотрю тут id снова одинаковый, на 10 потоков и 10 заданий у меня вышло 5 дублей

имя потока - нет я брал его вот таким образом: http://stackoverflow.com/questions/17707775/get-thread-id-or-name-in-python-2-6 и у меня получались дубли

а одни и те же потоки выполняют разный код, но разный код зависит от своих переменных?

не уверен что правильно вас понял. скажу как понимаю, код что выполняют потоки одинаковый, но у каждого потока должен быть своя копия переменных которая не пересекается между потоками, и которую можно шарить между модулями

вашу идею пока что понять не удаётся(

Думал об этом, но тут получается что потоки ломятся в один словарь и выходит не безопасно, начинается конкуренция и вылетать ошибки

Чтобы такого не было, каждый поток перед изменением объекта блокирует его для изменения другими потоками.

Понял идею, всё равно какой-то говнокод получается - есть варианты без блоков, чую есть решение где-то рядом, не могу его найти

threading.local()

я смотрю тут id снова одинаковый, на 10 потоков и 10 заданий у меня вышло 5 дублей

Ты использовал threading.local, и разные потоки меняли значение друг у друга? Покажи код.

Ребят попробую попроще выразить суть задачи, может так проще будет помочь.

Даны файлы a.py, b.py, c.py, d.py

a.py многопоточно запускает функцию внутри b.py, а та вызывает в свою очередь функции из c.py, а та из d.py

На уровне a.py присваивается переменная test = «что-то_там», присваивание происходит внутри потока, у каждого потока своё значение переменной

Вопрос: как мне видеть переменную test внутри файлов b, c, d?

да, вот код main.py:

from queue import *
from threading import Thread, local


def doo2():
    task = q_src.get()  # task_0
    print(local())
    q_src.task_done()

q_src = Queue(maxsize=0)
num_threads = 10


# функция обработки потоков
def do_stuff(q_src):
    while True:
        doo2()

# запуск потоков
for i in range(num_threads):
  worker = Thread(target=do_stuff, args=(q_src,))
  worker.setDaemon(True)
  worker.start()

# закидываем задания на исполнение
for x in range(10):
  q_src.put("task_" + str(x))


q_src.join()
print("работа выполнена")

Что я должен был увидеть из этого примера? Или ты не понимаешь, как используется threading.local?

Это объект, значения полей которого для всех разные — такие, какие они сохранили. Как указано в документации:

mydata = threading.local()
mydata.x = 1

Так словари в питоне thread safe на атомарных операциях.

Я в питоне очень слабоват, сперва не так понял locals(). Огромное спасибо за разъяснения! Только их пока что мне не удаётся к делу пришить, квалификация моя слабовата. Не сочтите за наглость, не могли бы вы пожалуйста запилить небольшой пример как реализовать описанную мной задачу? На базе того кода что я выложил

Тут вычитал что юзать не рекомендуют http://stackoverflow.com/questions/3358770/python-dictionary-is-thread-safe

На базе того кода что я выложил

А как примерно используется эта общая переменная?

Тут вычитал что юзать не рекомендуют

Там написано только, что вот так делать нельзя:

for key in mydict:
    mydict["новый ключ"] = "что-нибудь"

Типовое использование - это поменять строку на новую, добавив к исходной что-то новое.

Там много разных переменных, словари, списки и.т.д., можно добавить в список элемент, соответственно в других местах я должен увидеть изменённый список.

Упс, английский я тоже слабовато знаю..)

мог бы ты реализовать свою задачу на любом другом языке? у тебя не с питоном или словарями проблема, а в дизайне. defective by design and overcomplicated. можем начать с одного модуля без потоков и процессов, чтоб понять какие ты делаешь вычисления? тут все очень зависит, и бывает что локи сводят на нет приимущества. может ты делаешь тестовое, но тогда сам разберись.

возможно, поще всего тебе будет использовать готовое решение вроде редиски или любого in-memory хранилища, реализованного в самом питоне, посмотри примеры их использования - ты делаешь то же самое

Типовое использование - это поменять строку на новую, добавив к исходной что-то новое.

Я говорю, что в переменных-то хранится?

Там много разных переменных, словари, списки и.т.д., можно добавить в список элемент, соответственно в других местах я должен увидеть изменённый список.

Ну например? Я не могу понять, почему они должны быть привязаны к потокам, а не к задачам.

a.py многопоточно запускает функцию внутри b.py

давай начнем сначала, объясни другими словами?

На другом - нет не мог бы, других ЯП не знаю. Да я понимаю что дизайн плохой, как его лучше сделать пока что не понял, с этим и пришёл к вам.

В целом задача выглядит так: мне надо многопоточно зайти на каждый сайт из списка, там поработать, и записать отчёт в файл. У меня есть на входе URL сайта и данные к нему, и мне надо на выходе получить результаты работы по каждому потоку.

Всё в общем то работало нормально до тех пор пока я не разбить главный код на множество модулей, тут-то и начались проблемы дизайна.

Делаю не тестовое.

короче, я все понял. храни данные как хочешь, а когда они нужны - явно передавай, вот и все дела

многопоточность это сложно

В переменных хранится состояние работы каждого потока. И мне надо это состояние потока видеть из разных модулей. Пример привести затрудняюсь, выше я там камраду ответил что делаю возможно это прояснит ход дела.

Я начинающий, если можно не через потоки а через задачи сделать - напишите пожалуйста в двух словах как этот дизайн выглядит.

асинхронный ввод-вывод (сетевой), коллбеки, корутины, для очереди задач лучше все-таки использовать какое-то хранилище, т.к. задачи скорее всего придется добавлять в очередь из воркеров для балансировки

задача весьма нетривиальна для новичка, почему не хочешь взять готовую разработку, коих масса на гитхабе?

вот простой пример для торнадо http://www.tornadoweb.org/en/stable/guide/queues.html английский все-равно надо учить

Каждый поток запускает функцию и передаёт ей задание. Функция берёт из задания сайт и данные к нему, и идёт с ним работать.

Всё было хорошо пока код был в 1 файле, а мне надо всё по уму разделить - движок отдельно, то что на сайте делаю - отдельно, состояние работы текущего потока - отдельно. Так проще работать.

Если не то объяснил - дайте знать пожалуйста, по другому напишу.

Передавать прямо в функции во входных аргумента? Я так делал раньше, был там 1 мега словарь который я сувал из функции в фунцию целиком, геморойно это всё обслуживать, сильно избыточно

Да задача тривиальная, всё идеально работает когда код в 1 месте лежал, а как начал делить на движок и модуль который ему задание подкидывает - возникла эта проблема с потоками, начали они друг у друга затирать переменные своими значениями, каша вышла

Я и взял готовую разработку, проблема то не на уровне работы с сайтом

дело в том что это каша в голове, если проблема только в том что потоки «затирают» то выбери другую схему именования - по урлу задачи, например.

не пойму чем один файл принципиально от нескольких отличается.