Python-сообщество

Пытался сделать список, с которым можно было-бы безопасно работать, при использовании потоков. Получилось, примерно это:

class MyList:
    def __init__(self):
        self.__data = []
        self.__lock = threading.Lock()
    def __len__(self):
        with self.__lock:
            size = len(self.__data)
        return size
    def append(self, p_object):
        with self.__lock:
            self.__data.append(p_object)
    def pop(self, index=None):
        with self.__lock:
            if index:
                p_object = self.__data.pop(index)
            else:
                p_object = self.__data.pop(-1)
            return p_object
    def clear(self):
        with self.__lock:
            self.clear()

Отредактировано wegwgweg (Фев. 2, 2015 09:20:09)

wegwgweg
Подскажите пожалуйста, все ли я правильно сделал, может я чего-то не учёл?

PooH
Не учли что операции со списками в питоне

Отредактировано wegwgweg (Фев. 2, 2015 14:06:41)

а мне казалось для этого модуль Queue сделали

JOHN_16
Про Queue знаю, но нужно чтобы можно было посмотреть сразу все данные (на пример вывести на экран) или в цикле посмотреть все данные и при этом не опустошив список. С очередьми это невозможно, по этому горожу вот такие велосипеды.

Если есть более правильные способы решения проблемы, подскажите.

JOHN_16
Кстати подскажите пожалуйста, действительно, что все действия со списками атамарны и следовательно их можно применять при работе с потоками без опаски?

Отредактировано wegwgweg (Фев. 3, 2015 14:06:34)

wegwgweg
Простое гугление по запрос Python list atomic operation первой же ссылкой ведет нас на Stack Overflow, где дается ответ, а так же есть сылка на эту заметку, где показаны какие операции являются потоко-безопасными, а какие нет. Вот пример оттуда:

For example, the following operations are all atomic (L, L1, L2 are lists, D, D1, D2 are dicts, x, y are objects, i, j are ints):

L.append(x)
L1.extend(L2)
x = L[i]
x = L.pop()
L1[i:j] = L2
L.sort()
x = y
x.field = y
D[x] = y
D1.update(D2)
D.keys()

These aren’t:

i = i+1
L.append(L[-1])
L[i] = L[j]
D[x] = D[x] + 1

Deques are a generalization of stacks and queues (the name is pronounced “deck” and is short for “double-ended queue”). Deques support thread-safe, memory efficient appends and pops from either side of the deque with approximately the same O(1) performance in either direction.

Что то я засомневался в атомарности. Вот, например, байт код для ls.append

3           15 LOAD_FAST                 0 (ls)
             18 LOAD_ATTR                 0 (append)
             21 LOAD_CONST              4 (4)
             24 CALL_FUNCTION          1
             27 POP_TOP