programming python

Hướng dẫn python thread only runs once - chuỗi trăn chỉ chạy một lần

Tôi đang cố gắng thực hiện luồng nhưng nó chỉ chạy một lần thay vì chạy liên tục.

Đây là nơi tôi đang tạo các luồng và gọi các chức năng:

thread_list = []
for ldx, stream in enumerate[input_stream_list]:
   thread = threading.Thread[target=frame_thread, args=[stream, "stream{0}".format[ldx], ldx]]
   thread_list.append[thread]

for thread in thread_list:
   thread.start[]

retrieve_thread_list = []
for kdx, streamk in enumerate[input_stream_list]:
   threadk = threading.Thread[target=retrieve_thread, args=[streamk, kdx]]
   retrieve_thread_list.append[threadk]

for threadk in retrieve_thread_list:
   threadk.start[]

for thread in thread_list:
   thread.join[]

for threadk in retrieve_thread_list:
   threadk.join[]

while True:
   pass

Đây là việc triển khai frame_thread:-


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY

Và đây là chức năng retrieve_thread của tôi: -

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL

Threadk - retrieve_thread chỉ thực thi một lần. Tôi đang làm gì sai?

Mã nguồn: lib/threading.py Lib/threading.py

Mô-đun này xây dựng các giao diện luồng cấp cao hơn ở đầu mô-đun 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
4 cấp thấp hơn.

Đã thay đổi trong phiên bản 3.7: Mô -đun này được sử dụng là tùy chọn, giờ đây nó luôn có sẵn.This module used to be optional, it is now always available.

Xem thêm


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
5 cung cấp giao diện cấp cao hơn để đẩy các tác vụ vào một luồng nền mà không chặn thực thi luồng gọi, trong khi vẫn có thể truy xuất kết quả của họ khi cần thiết.


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
6 cung cấp giao diện an toàn luồng để trao đổi dữ liệu giữa các luồng đang chạy.


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
7 cung cấp một cách tiếp cận thay thế để đạt được sự đồng thời cấp độ nhiệm vụ mà không yêu cầu sử dụng nhiều luồng hệ điều hành.

Ghi chú

Trong sê -ri Python 2.x, mô -đun này chứa các tên 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
8 cho một số phương thức và chức năng. Chúng không được chấp nhận như Python 3.10, nhưng chúng vẫn được hỗ trợ để tương thích với Python 2.5 trở xuống.

Chi tiết triển khai CPython: Trong CPython, do khóa phiên dịch toàn cầu, chỉ một luồng có thể thực thi mã python cùng một lúc [mặc dù các thư viện định hướng hiệu suất nhất định có thể khắc phục giới hạn này]. Nếu bạn muốn ứng dụng của mình sử dụng tốt hơn các tài nguyên tính toán của các máy đa lõi, bạn nên sử dụng 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
9 hoặc 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
0. Tuy nhiên, luồng vẫn là một mô hình thích hợp nếu bạn muốn chạy đồng thời nhiều tác vụ ràng buộc I/O. In CPython, due to the Global Interpreter Lock, only one thread can execute Python code at once [even though certain performance-oriented libraries might overcome this limitation]. If you want your application to make better use of the computational resources of multi-core machines, you are advised to use 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
9 or 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
0. However, threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously.

Mô -đun này xác định các chức năng sau:

________ 21 ________ 22 [][]

Trả về số lượng đối tượng 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
3 hiện còn sống. Số lượng được trả về bằng độ dài của danh sách được trả về bởi 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
4.

Hàm 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
5 là bí danh không dùng nữa cho chức năng này.

________ 21 ________ 27 [][]

Trả về đối tượng 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
3 hiện tại, tương ứng với luồng điều khiển của người gọi. Nếu luồng điều khiển của người gọi không được tạo thông qua mô -đun 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
9, một đối tượng chủ đề giả có chức năng hạn chế được trả về.

Hàm 

mydata = threading.local[]
mydata.x = 1
0 là bí danh không dùng nữa cho chức năng này.

________ 21 ________ 32 [args, /] ¶[args, /]

Xử lý ngoại lệ chưa được nâng lên bởi 

mydata = threading.local[]
mydata.x = 1
3.

Đối số ARGS có các thuộc tính sau:

  • exc_type: loại ngoại lệ.

  • EXC_VALUE: Giá trị ngoại lệ, có thể là 

    mydata = threading.local[]
mydata.x = 1
    4.

  • EXC_TRACEBACK: Traceback ngoại lệ, có thể là 

    mydata = threading.local[]
mydata.x = 1
    4.

  • Chủ đề: Chủ đề nâng cao ngoại lệ, có thể là 

    mydata = threading.local[]
mydata.x = 1
    4.

Nếu exc_type là 

mydata = threading.local[]
mydata.x = 1
7, ngoại lệ bị bỏ qua âm thầm. Nếu không, ngoại lệ được in ra trên 
mydata = threading.local[]
mydata.x = 1
8.

Nếu chức năng này tăng một ngoại lệ, 

mydata = threading.local[]
mydata.x = 1
9 được gọi để xử lý nó.

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
0 có thể được ghi đè để kiểm soát các trường hợp ngoại lệ chưa được thực hiện bởi 
mydata = threading.local[]
mydata.x = 1
3 được xử lý.

Lưu trữ exc_value bằng cách sử dụng móc tùy chỉnh có thể tạo chu kỳ tham chiếu. Nó nên được xóa rõ ràng để phá vỡ chu kỳ tham chiếu khi ngoại lệ không còn cần thiết.

Lưu trữ luồng bằng cách sử dụng một móc tùy chỉnh có thể hồi sinh nó nếu nó được đặt thành một đối tượng đang được hoàn thiện. Tránh lưu trữ chủ đề sau khi móc tùy chỉnh hoàn thành để tránh phục hồi các đối tượng.

Mới trong phiên bản 3.8.

________ 21 ________ 43¶

Giữ giá trị ban đầu của 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
0. Nó được lưu để giá trị ban đầu có thể được khôi phục trong trường hợp chúng tình cờ được thay thế bằng các đối tượng bị hỏng hoặc thay thế.

Mới trong phiên bản 3.10.

________ 21 ________ 46 [][]

Trả về ‘định danh luồng, của luồng hiện tại. Đây là một số nguyên khác nhau. Giá trị của nó không có ý nghĩa trực tiếp; Nó được dự định là một cookie ma thuật được sử dụng, ví dụ: Để lập chỉ mục một từ điển của dữ liệu cụ thể theo luồng. Định danh luồng có thể được tái chế khi một luồng thoát ra và một luồng khác được tạo.

Mới trong phiên bản 3.3.

________ 21 ________ 48 [][]

Trả về ID luồng tích phân gốc của luồng hiện tại được gán bởi kernel. Đây là một số nguyên không âm. Giá trị của nó có thể được sử dụng để xác định duy nhất toàn bộ hệ thống chủ đề này [cho đến khi luồng kết thúc, sau đó giá trị có thể được tái chế bởi HĐH].

Tính khả dụng: Windows, FreeBSD, Linux, MacOS, OpenBSD, NetBSD, AIX.: Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD, AIX.

Mới trong phiên bản 3.8.

________ 21 ________ 43¶[]

Giữ giá trị ban đầu của 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
0. Nó được lưu để giá trị ban đầu có thể được khôi phục trong trường hợp chúng tình cờ được thay thế bằng các đối tượng bị hỏng hoặc thay thế.

Mới trong phiên bản 3.10.[]

________ 21 ________ 46 []

Trả về ‘định danh luồng, của luồng hiện tại. Đây là một số nguyên khác nhau. Giá trị của nó không có ý nghĩa trực tiếp; Nó được dự định là một cookie ma thuật được sử dụng, ví dụ: Để lập chỉ mục một từ điển của dữ liệu cụ thể theo luồng. Định danh luồng có thể được tái chế khi một luồng thoát ra và một luồng khác được tạo.

Mới trong phiên bản 3.3.[func]

________ 21 ________ 48 []

Trả về ID luồng tích phân gốc của luồng hiện tại được gán bởi kernel. Đây là một số nguyên không âm. Giá trị của nó có thể được sử dụng để xác định duy nhất toàn bộ hệ thống chủ đề này [cho đến khi luồng kết thúc, sau đó giá trị có thể được tái chế bởi HĐH].[]

Tính khả dụng: Windows, FreeBSD, Linux, MacOS, OpenBSD, NetBSD, AIX.

Mới trong phiên bản 3.10.

________ 21 ________ 46 [][func]

Trả về ‘định danh luồng, của luồng hiện tại. Đây là một số nguyên khác nhau. Giá trị của nó không có ý nghĩa trực tiếp; Nó được dự định là một cookie ma thuật được sử dụng, ví dụ: Để lập chỉ mục một từ điển của dữ liệu cụ thể theo luồng. Định danh luồng có thể được tái chế khi một luồng thoát ra và một luồng khác được tạo.

Mới trong phiên bản 3.3.[]

________ 21 ________ 48 []

Mới trong phiên bản 3.10.

________ 21 ________ 46 [][[size]]

Trả về ‘định danh luồng, của luồng hiện tại. Đây là một số nguyên khác nhau. Giá trị của nó không có ý nghĩa trực tiếp; Nó được dự định là một cookie ma thuật được sử dụng, ví dụ: Để lập chỉ mục một từ điển của dữ liệu cụ thể theo luồng. Định danh luồng có thể được tái chế khi một luồng thoát ra và một luồng khác được tạo.

Tính khả dụng: Windows, hệ thống với các chủ đề POSIX.: Windows, systems with POSIX threads.

Mô -đun này cũng xác định hằng số sau:

________ 21 ________ 77¶

Giá trị tối đa được phép cho tham số thời gian chờ của các hàm chặn [

maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
8, 
maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
9, 
with pool_sema:
    conn = connectdb[]
    try:
        # ... use connection ...
    finally:
        conn.close[]
0, v.v.]. Chỉ định thời gian chờ lớn hơn giá trị này sẽ tăng 
with pool_sema:
    conn = connectdb[]
    try:
        # ... use connection ...
    finally:
        conn.close[]
1.

Mới trong phiên bản 3.2.

Mô -đun này xác định một số lớp, được chi tiết trong các phần dưới đây.

Thiết kế của mô -đun này dựa trên mô hình luồng Java. Tuy nhiên, trong đó Java tạo khóa và biến điều kiện hành vi cơ bản của mọi đối tượng, chúng là các đối tượng riêng biệt trong Python. Lớp Python từ 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
3 hỗ trợ một tập hợp con về hành vi của lớp chủ đề Java,; Hiện tại, không có ưu tiên, không có nhóm chủ đề và chủ đề không thể bị phá hủy, dừng lại, treo, tiếp tục hoặc bị gián đoạn. Các phương thức tĩnh của lớp luồng Java, khi được thực hiện, được ánh xạ tới các hàm cấp mô-đun.

Tất cả các phương pháp được mô tả dưới đây được thực thi về mặt nguyên tử.

Dữ liệu địa lý địa lý

Dữ liệu địa lý địa chỉ là dữ liệu có giá trị cụ thể của luồng. Để quản lý dữ liệu địa lý, chỉ cần tạo một thể hiện là 

with pool_sema:
    conn = connectdb[]
    try:
        # ... use connection ...
    finally:
        conn.close[]
3 [hoặc một lớp con] và lưu trữ các thuộc tính trên đó:

mydata = threading.local[]
mydata.x = 1

Các giá trị của phiên bản sẽ khác nhau đối với các luồng riêng biệt.

Lớp ________ 21 ________ 85¶

Một lớp đại diện cho dữ liệu địa lý.

Để biết thêm chi tiết và các ví dụ mở rộng, hãy xem chuỗi tài liệu của mô -đun 

with pool_sema:
    conn = connectdb[]
    try:
        # ... use connection ...
    finally:
        conn.close[]
6.

Đối tượng chủ đề

Lớp 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
3 đại diện cho một hoạt động được chạy trong một luồng điều khiển riêng biệt. Có hai cách để chỉ định hoạt động: bằng cách chuyển một đối tượng có thể gọi cho hàm tạo hoặc bằng cách ghi đè phương thức 
while not predicate[]:
    cv.wait[]
0 trong một lớp con. Không có phương thức nào khác [ngoại trừ hàm tạo] nên được ghi đè trong một lớp con. Nói cách khác, chỉ ghi đè các phương thức 
with pool_sema:
    conn = connectdb[]
    try:
        # ... use connection ...
    finally:
        conn.close[]
9 và 
while not predicate[]:
    cv.wait[]
0 của lớp này.

Khi một đối tượng luồng được tạo, hoạt động của nó phải được bắt đầu bằng cách gọi phương thức luồng ____ ____ ____. Điều này gọi phương thức 

while not predicate[]:
    cv.wait[]
0 trong một luồng điều khiển riêng biệt.

Khi hoạt động của chủ đề được bắt đầu, chủ đề được coi là ‘còn sống. Nó ngừng sống khi phương pháp 

while not predicate[]:
    cv.wait[]
0 của nó chấm dứt - thông thường hoặc bằng cách nâng cao một ngoại lệ chưa được xử lý. Phương pháp 
def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
4 kiểm tra xem luồng có còn sống hay không.

Các luồng khác có thể gọi một phương thức chủ đề ____ ____95. Điều này chặn luồng gọi cho đến khi luồng có phương thức 

def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
5 được gọi là chấm dứt.

Một chủ đề có một tên. Tên có thể được chuyển cho hàm tạo và đọc hoặc thay đổi thông qua thuộc tính 

def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
7.

Nếu phương thức 

while not predicate[]:
    cv.wait[]
0 tăng ngoại lệ, 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
0 được gọi để xử lý nó. Theo mặc định, 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
0 bỏ qua âm thầm 
mydata = threading.local[]
mydata.x = 1
7.

Một chủ đề có thể được gắn cờ dưới dạng chủ đề Daemon Daemon. Tầm quan trọng của lá cờ này là toàn bộ chương trình Python thoát ra khi chỉ còn lại các luồng daemon. Giá trị ban đầu được kế thừa từ chủ đề tạo. Cờ có thể được đặt thông qua thuộc tính 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
02 hoặc đối số trình xây dựng daemon.

Ghi chú

Chủ đề daemon đột ngột dừng lại khi tắt máy. Tài nguyên của họ [như các tệp mở, giao dịch cơ sở dữ liệu, v.v.] không được phát hành đúng. Nếu bạn muốn các chủ đề của mình dừng lại một cách duyên dáng, hãy làm cho chúng không phải là Daemonic và sử dụng một cơ chế báo hiệu phù hợp như 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
03.

Có một đối tượng chủ đề chính của người Viking; Điều này tương ứng với luồng điều khiển ban đầu trong chương trình Python. Nó không phải là một chủ đề daemon.

Có khả năng các đối tượng chủ đề giả của người Viking được tạo ra. Đây là các đối tượng chủ đề tương ứng với các chủ đề của người ngoài hành tinh, đó là các luồng điều khiển bắt đầu bên ngoài mô -đun luồng, chẳng hạn như trực tiếp từ mã C. Các đối tượng chủ đề giả có chức năng hạn chế; Chúng luôn được coi là sống và daemonic, và không thể được ____995ed. Họ không bao giờ bị xóa, vì không thể phát hiện việc chấm dứt các chủ đề ngoài hành tinh.

Lớp ________ 21 ________ 106 [nhóm = none, target = none, name = none, args = [], kwargs = {}, *, daemon = none][group=None, target=None, name=None, args=[], kwargs={}, *, daemon=None]

Trình xây dựng này phải luôn luôn được gọi với các đối số từ khóa. Đối số là:

Nhóm phải là 

mydata = threading.local[]
mydata.x = 1
4; Dành riêng cho phần mở rộng trong tương lai khi một lớp 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
08 được thực hiện.

Mục tiêu là đối tượng có thể gọi được được gọi bằng phương thức 

while not predicate[]:
    cv.wait[]
0. Mặc định là 
mydata = threading.local[]
mydata.x = 1
4, có nghĩa là không có gì được gọi.

Tên là tên chủ đề. Theo mặc định, một tên duy nhất được xây dựng theo mẫu của chủ đề n, trong đó n là một số thập phân nhỏ, hoặc chủ đề của N [mục tiêu], trong đó, mục tiêu là 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
11 nếu đối số đích được chỉ định.

args là tuple đối số cho việc gọi mục tiêu. Mặc định là 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
12.

KWARGS là một từ điển của các đối số từ khóa cho việc gọi mục tiêu. Mặc định là 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
13.

Nếu không phải là 

mydata = threading.local[]
mydata.x = 1
4, Daemon đặt rõ ràng liệu chủ đề có phải là daemonic hay không. Nếu 
mydata = threading.local[]
mydata.x = 1
4 [mặc định], thuộc tính daemon được kế thừa từ luồng hiện tại.

Nếu lớp con ghi đè hàm tạo, nó phải đảm bảo gọi hàm tạo lớp cơ sở [


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
16] trước khi làm bất cứ điều gì khác với luồng.

Đã thay đổi trong phiên bản 3.10: Sử dụng tên đích nếu đối số tên bị bỏ qua.Use the target name if name argument is omitted.

Đã thay đổi trong phiên bản 3.3: Đã thêm đối số daemon.Added the daemon argument.

________ 117 [][]

Bắt đầu hoạt động chủ đề.

Nó phải được gọi nhiều nhất một lần cho mỗi đối tượng chủ đề. Nó sắp xếp cho phương thức đối tượng ____ ____60 được gọi trong một luồng điều khiển riêng biệt.

Phương pháp này sẽ tăng 

maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
4 nếu được gọi nhiều hơn một lần trên cùng một đối tượng luồng.

________ 120 [][]

Phương pháp đại diện cho hoạt động của chủ đề.

Bạn có thể ghi đè phương thức này trong một lớp con. Phương thức 

while not predicate[]:
    cv.wait[]
0 tiêu chuẩn gọi đối tượng có thể gọi được chuyển đến hàm tạo đối tượng là đối số đích, nếu có, với các đối số từ khóa và vị trí được lấy từ các đối số ARGS và KWARGS, tương ứng.

________ 122 [thời gian chờ = Không] ¶[timeout=None]

Đợi cho đến khi chủ đề chấm dứt. Điều này chặn luồng gọi cho đến khi luồng có phương thức 

def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
5 được gọi là chấm dứt - thông thường hoặc thông qua ngoại lệ chưa được xử lý - hoặc cho đến khi thời gian chờ tùy chọn xảy ra.

Khi đối số thời gian chờ có mặt chứ không phải 

mydata = threading.local[]
mydata.x = 1
4, nó sẽ là một số điểm nổi chỉ định thời gian chờ cho hoạt động tính bằng giây [hoặc phân số của chúng]. Vì 
def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
5 luôn trả về 
mydata = threading.local[]
mydata.x = 1
4, bạn phải gọi 
def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
4 sau khi 
def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
5 để quyết định xem thời gian chờ có xảy ra hay không - nếu luồng vẫn còn sống, cuộc gọi 
def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
5 đã hết thời gian.

Khi đối số thời gian chờ không có hoặc 

mydata = threading.local[]
mydata.x = 1
4, thao tác sẽ chặn cho đến khi luồng kết thúc.

Một chủ đề có thể được 

def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
5ed nhiều lần.

def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
5 tăng 
maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
4 nếu một nỗ lực được thực hiện để tham gia vào luồng hiện tại vì điều đó sẽ gây bế tắc. Nó cũng là một lỗi đối với 
def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
5 một chủ đề trước khi nó được bắt đầu và cố gắng thực hiện việc nâng cao ngoại lệ tương tự.

________ 135¶

Một chuỗi được sử dụng cho mục đích nhận dạng. Nó không có ngữ nghĩa. Nhiều luồng có thể được đặt cùng một tên. Tên ban đầu được đặt bởi hàm tạo.

________ 136 [] ________ 137 [][]

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
37[]

API getter/setter không dùng nữa cho 

def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
7; sử dụng nó trực tiếp làm tài sản thay thế.

Không dùng nữa kể từ phiên bản 3.10.

________ 139¶

Định danh ’luồng của chủ đề này hoặc 

mydata = threading.local[]
mydata.x = 1
4 nếu luồng chưa được bắt đầu. Đây là một số nguyên khác nhau. Xem hàm 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
41. Định danh luồng có thể được tái chế khi một luồng thoát ra và một luồng khác được tạo. Mã định danh có sẵn ngay cả sau khi chủ đề đã thoát.

________ 142¶

ID luồng [


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
43] của chủ đề này, như được chỉ định bởi HĐH [kernel]. Đây là một số nguyên không âm hoặc 
mydata = threading.local[]
mydata.x = 1
4 nếu chủ đề chưa được bắt đầu. Xem hàm 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
45. Giá trị này có thể được sử dụng để xác định duy nhất toàn bộ hệ thống luồng cụ thể này [cho đến khi luồng kết thúc, sau đó giá trị có thể được tái chế bởi HĐH].

Ghi chú

Tương tự như ID xử lý, ID luồng chỉ hợp lệ [được bảo đảm toàn bộ hệ thống] kể từ khi luồng được tạo cho đến khi luồng bị chấm dứt.

Tính khả dụng: Yêu cầu chức năng 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
45.: Requires 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
45 function.

Mới trong phiên bản 3.8.

________ 147 [][]

Trả lại liệu chủ đề còn sống.

Phương pháp này trả về 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 ngay trước khi phương thức 
while not predicate[]:
    cv.wait[]
0 bắt đầu cho đến khi phương thức 
while not predicate[]:
    cv.wait[]
0 chấm dứt. Hàm mô -đun 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
4 trả về danh sách tất cả các luồng còn sống.

________ 152¶

Một giá trị boolean cho biết liệu luồng này có phải là một luồng daemon hay không [


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48] hay không [

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54]. Điều này phải được đặt trước khi 
def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
1 được gọi, nếu không 
maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
4 được nâng lên. Giá trị ban đầu của nó được kế thừa từ chủ đề tạo; Chủ đề chính không phải là một luồng daemon và do đó tất cả các luồng được tạo trong luồng chính mặc định là 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
02 = 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54.

Toàn bộ chương trình Python thoát ra khi không còn chủ đề không phải là Daemon.

________ 159 [] ____ ____ 160 [][]

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
60[]

API getter/setter không dùng nữa cho 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
02; sử dụng nó trực tiếp làm tài sản thay thế.

Không dùng nữa kể từ phiên bản 3.10.

________ 139¶

Định danh ’luồng của chủ đề này hoặc 

mydata = threading.local[]
mydata.x = 1
4 nếu luồng chưa được bắt đầu. Đây là một số nguyên khác nhau. Xem hàm 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
41. Định danh luồng có thể được tái chế khi một luồng thoát ra và một luồng khác được tạo. Mã định danh có sẵn ngay cả sau khi chủ đề đã thoát.

________ 142¶

Khóa cũng hỗ trợ giao thức quản lý bối cảnh.context management protocol.

Khi có nhiều hơn một luồng bị chặn trong 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 đang chờ trạng thái chuyển sang mở khóa, chỉ có một luồng tiến hành khi cuộc gọi 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64 đặt lại trạng thái để mở khóa; Một trong những chủ đề đang chờ tiến hành không được xác định và có thể thay đổi giữa các triển khai.

Tất cả các phương pháp được thực thi về mặt nguyên tử.

Lớp ________ 21 ________ 174¶

Lớp thực hiện các đối tượng khóa nguyên thủy. Khi một luồng đã có được một khóa, các nỗ lực tiếp theo để có được khối nó, cho đến khi nó được phát hành; Bất kỳ chủ đề có thể phát hành nó.

Lưu ý rằng 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
75 thực sự là một chức năng nhà máy trả về một phiên bản hiệu quả nhất của lớp khóa bê tông được hỗ trợ bởi nền tảng.

________ 176 [chặn = true, thời gian chờ =- 1] ¶[blocking=True, timeout=- 1]

Có được một khóa, chặn hoặc không chặn.

Khi được gọi với đối số chặn được đặt thành 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 [mặc định], chặn cho đến khi khóa được mở khóa, sau đó đặt nó thành khóa và trả lại 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48.

Khi được gọi với đối số chặn được đặt thành 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54, không chặn. Nếu một cuộc gọi với chặn được đặt thành 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 sẽ chặn, hãy trả lại 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54 ngay lập tức; Nếu không, đặt khóa thành khóa và trả lại 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48.

Khi được gọi với đối số thời gian chờ điểm nổi được đặt thành giá trị dương, khối trong nhiều nhất số giây được chỉ định bởi thời gian chờ và miễn là khóa không thể có được. Một đối số thời gian chờ của 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
83 chỉ định một sự chờ đợi không giới hạn. Nó bị cấm chỉ định thời gian chờ khi chặn là 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54.

Giá trị trả về là 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 nếu khóa được thu được thành công, 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54 nếu không [ví dụ: nếu thời gian chờ hết hạn].

Đã thay đổi trong phiên bản 3.2: Tham số thời gian chờ là mới.The timeout parameter is new.

Đã thay đổi trong phiên bản 3.2: Việc thu nhận khóa hiện có thể bị gián đoạn bởi các tín hiệu trên POSIX nếu việc triển khai luồng cơ bản hỗ trợ nó.Lock acquisition can now be interrupted by signals on POSIX if the underlying threading implementation supports it.

________ 187 [][]

Phát hành khóa. Điều này có thể được gọi từ bất kỳ chủ đề nào, không chỉ các luồng đã có được khóa.

Khi khóa được khóa, đặt lại để mở khóa và quay lại. Nếu bất kỳ luồng nào khác bị chặn chờ khóa được mở khóa, hãy cho phép chính xác một trong số chúng tiến hành.

Khi được gọi trên một khóa không khóa, một 

maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
4 được nâng lên.

Không có giá trị quay lại.

________ 189 [][]

Trả lại 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 nếu khóa được thu thập.

Đối tượng rlock

Khóa reentrant là một nguyên thủy đồng bộ hóa có thể có được nhiều lần bởi cùng một luồng. Trong nội bộ, nó sử dụng các khái niệm về việc sở hữu chủ đề của người Hồi giáo và cấp độ đệ quy, ngoài trạng thái bị khóa/mở khóa được sử dụng bởi các khóa nguyên thủy. Ở trạng thái bị khóa, một số chủ đề sở hữu khóa; Trong trạng thái mở khóa, không có chủ đề sở hữu nó.

Để khóa khóa, một luồng gọi phương thức 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 của nó; Điều này trả về một khi luồng sở hữu khóa. Để mở khóa khóa, một luồng gọi phương thức 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64 của nó. ________ 163/________ 164 Các cặp cuộc gọi có thể được lồng; Chỉ có 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64 cuối cùng [

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64 của cặp ngoài cùng] đặt lại khóa để mở khóa và cho phép một luồng khác bị chặn trong 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 để tiến hành.

Khóa reentrant cũng hỗ trợ giao thức quản lý bối cảnh.context management protocol.

Lớp ________ 21 ________ 199¶

Lớp này thực hiện các đối tượng khóa Reentrant. Một khóa reentrant phải được phát hành bởi chủ đề có được nó. Khi một luồng đã có được một khóa reentrant, cùng một luồng có thể có được nó một lần nữa mà không chặn; Chủ đề phải phát hành nó một lần cho mỗi lần nó có được nó.

Lưu ý rằng 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
00 thực sự là một chức năng nhà máy trả về một phiên bản hiệu quả nhất của lớp rlock cụ thể được hỗ trợ bởi nền tảng.

________ 176 [chặn = true, thời gian chờ =- 1] ¶[blocking=True, timeout=- 1]

Có được một khóa, chặn hoặc không chặn.

Khi được gọi với đối số chặn được đặt thành 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 [mặc định], chặn cho đến khi khóa được mở khóa, sau đó đặt nó thành khóa và trả lại 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48.

Khi được gọi với đối số chặn được đặt thành 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54, không chặn. Nếu một cuộc gọi với chặn được đặt thành 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 sẽ chặn, hãy trả lại 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54 ngay lập tức; Nếu không, đặt khóa thành khóa và trả lại 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48.

Khi được gọi với đối số thời gian chờ điểm nổi được đặt thành giá trị dương, khối trong nhiều nhất số giây được chỉ định bởi thời gian chờ và miễn là khóa không thể có được. Một đối số thời gian chờ của 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
83 chỉ định một sự chờ đợi không giới hạn. Nó bị cấm chỉ định thời gian chờ khi chặn là 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54.

Giá trị trả về là 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 nếu khóa được thu được thành công, 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54 nếu không [ví dụ: nếu thời gian chờ hết hạn].

Đã thay đổi trong phiên bản 3.2: Tham số thời gian chờ là mới.The timeout parameter is new.

________ 187 [][]

Phát hành khóa, giảm mức đệ quy. Nếu sau khi giảm, nó bằng không, hãy đặt lại khóa để mở khóa [không thuộc sở hữu của bất kỳ luồng nào] và nếu bất kỳ luồng nào khác bị chặn chờ khóa được mở khóa, hãy cho phép chính xác một trong số chúng tiến hành. Nếu sau khi giảm mức đệ quy vẫn còn khác, thì khóa vẫn bị khóa và sở hữu bởi luồng gọi.

Chỉ gọi phương thức này khi luồng gọi sở hữu khóa. Một 

maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
4 được nâng lên nếu phương thức này được gọi khi khóa được mở khóa.

Không có giá trị quay lại.

Đối tượng điều kiện lor

Một biến điều kiện luôn được liên kết với một số loại khóa; Điều này có thể được thông qua hoặc một sẽ được tạo theo mặc định. Vượt qua một trong là hữu ích khi một số biến điều kiện phải chia sẻ cùng một khóa. Khóa là một phần của đối tượng điều kiện: bạn không phải theo dõi nó một cách riêng biệt.

Một biến điều kiện tuân theo giao thức quản lý bối cảnh: Sử dụng câu lệnh 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
11 có được khóa liên quan trong suốt thời lượng của khối kèm theo. Các phương thức 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 và 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64 cũng gọi các phương thức tương ứng của khóa được liên kết.context management protocol: using the 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
11 statement acquires the associated lock for the duration of the enclosed block. The 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 and 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64 methods also call the corresponding methods of the associated lock.

Các phương pháp khác phải được gọi với khóa liên kết được giữ. Phương thức 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 giải phóng khóa, và sau đó chặn cho đến khi một luồng khác đánh thức nó bằng cách gọi 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
15 hoặc 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
16. Sau khi đánh thức, 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 lại mua lại khóa và trả về. Cũng có thể chỉ định thời gian chờ.

Phương pháp 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
15 đánh thức một trong các luồng đang chờ biến điều kiện, nếu có đang chờ. Phương pháp 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
16 đánh thức tất cả các luồng chờ biến điều kiện.

Lưu ý: Các phương thức 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
15 và 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
16 don don phát hành khóa; Điều này có nghĩa là các luồng hoặc luồng được đánh thức sẽ không trở lại từ cuộc gọi 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 của họ ngay lập tức, mà chỉ khi chủ đề gọi 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
15 hoặc 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
16 cuối cùng đã từ bỏ quyền sở hữu khóa.

Kiểu lập trình điển hình sử dụng các biến điều kiện sử dụng khóa để đồng bộ hóa quyền truy cập vào một số trạng thái chung; Các chủ đề quan tâm đến một sự thay đổi cụ thể của cuộc gọi trạng thái 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 liên tục cho đến khi họ nhìn thấy trạng thái mong muốn, trong khi các luồng sửa đổi trạng thái gọi 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
15 hoặc 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
16 khi chúng thay đổi trạng thái theo cách có thể là trạng thái mong muốn đối với một trong những người phục vụ bàn. Ví dụ, mã sau đây là tình huống người tiêu dùng nhà sản xuất chung với dung lượng bộ đệm không giới hạn:

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]

Vòng lặp 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
28 Kiểm tra điều kiện ứng dụng là cần thiết vì 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 có thể quay lại sau một thời gian dài tùy ý và điều kiện khiến cuộc gọi 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
15 có thể không còn đúng nữa. Điều này là vốn có của lập trình đa luồng. Phương pháp 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
31 có thể được sử dụng để tự động hóa việc kiểm tra điều kiện và giảm bớt tính toán thời gian chờ:

# Consume an item
with cv:
    cv.wait_for[an_item_is_available]
    get_an_available_item[]

Để lựa chọn giữa 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
15 và 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
16, hãy xem xét liệu một thay đổi trạng thái có thể thú vị đối với chỉ một hoặc một số luồng chờ hay không. Ví dụ. Trong một tình huống tiêu chuẩn nhà sản xuất điển hình, việc thêm một mặt hàng vào bộ đệm chỉ cần đánh thức một luồng người tiêu dùng.

Lớp ________ 21 ________ 235 [khóa = Không] ¶[lock=None]

Lớp này thực hiện các đối tượng biến điều kiện. Một biến điều kiện cho phép một hoặc nhiều luồng chờ đợi cho đến khi chúng được thông báo bởi một luồng khác.

Nếu đối số khóa được đưa ra chứ không phải 

mydata = threading.local[]
mydata.x = 1
4, thì đó phải là đối tượng 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
75 hoặc 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
00 và nó được sử dụng làm khóa bên dưới. Mặt khác, một đối tượng 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
00 mới được tạo và sử dụng làm khóa bên dưới.

Thay đổi trong phiên bản 3.3: Thay đổi từ chức năng nhà máy sang một lớp.changed from a factory function to a class.

________ 176 [*args] ¶[*args]

Có được khóa cơ bản. Phương pháp này gọi phương thức tương ứng trên khóa bên dưới; Giá trị trả về là bất cứ điều gì phương thức đó trả về.

________ 187 [][]

Phát hành khóa cơ bản. Phương pháp này gọi phương thức tương ứng trên khóa bên dưới; không có giá trị quay lại.

________ 242 [thời gian chờ = Không] ¶[timeout=None]

Chờ cho đến khi được thông báo hoặc cho đến khi thời gian chờ xảy ra. Nếu luồng cuộc gọi không có được khóa khi phương thức này được gọi, một 

maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
4 sẽ được nâng lên.

Phương pháp này phát hành khóa bên dưới, và sau đó chặn cho đến khi nó được đánh thức bởi một cuộc gọi 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
15 hoặc 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
16 cho cùng một biến điều kiện trong một luồng khác hoặc cho đến khi thời gian chờ tùy chọn xảy ra. Sau khi đánh thức hoặc hẹn giờ, nó lại mua lại khóa và trả lại.

Khi đối số thời gian chờ có mặt chứ không phải 

mydata = threading.local[]
mydata.x = 1
4, nó sẽ là một số điểm nổi chỉ định thời gian chờ cho hoạt động tính bằng giây [hoặc phân số của chúng].

Khi khóa bên dưới là 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
00, nó không được phát hành bằng phương pháp 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64 của nó, vì điều này có thể không thực sự mở khóa khóa khi nó được thu nhận nhiều lần. Thay vào đó, một giao diện nội bộ của lớp 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
00 được sử dụng, thực sự mở khóa nó ngay cả khi nó đã được thu nhận đệ quy nhiều lần. Một giao diện bên trong khác sau đó được sử dụng để khôi phục mức độ đệ quy khi khóa được phản ứng lại.

Giá trị trả về là 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 trừ khi hết thời gian chờ đã hết, trong trường hợp đó là 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54.

Đã thay đổi trong phiên bản 3.2: Trước đây, phương thức luôn được trả về 

mydata = threading.local[]
mydata.x = 1
4.Previously, the method always returned 
mydata = threading.local[]
mydata.x = 1
4.

________ 253 [vị từ, thời gian chờ = Không] ¶[predicate, timeout=None]

Đợi cho đến khi một điều kiện đánh giá là đúng. Vị từ phải là một cuộc gọi có thể gọi mà kết quả sẽ được hiểu là giá trị boolean. Một thời gian chờ có thể được cung cấp cho thời gian tối đa để chờ đợi.

Phương pháp tiện ích này có thể gọi 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 nhiều lần cho đến khi vị từ được thỏa mãn hoặc cho đến khi thời gian chờ xảy ra. Giá trị trả về là giá trị trả về cuối cùng của vị ngữ và sẽ đánh giá thành 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54 nếu phương thức hết thời gian.

Bỏ qua tính năng thời gian chờ, gọi phương thức này gần như tương đương với việc viết:

while not predicate[]:
    cv.wait[]

Do đó, các quy tắc tương tự được áp dụng như với 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14: Khóa phải được giữ khi được gọi và được mua lại khi trả lại. Các vị ngữ được đánh giá với khóa giữ.

Mới trong phiên bản 3.2.

________ 257 [n = 1][n=1]

Theo mặc định, đánh thức một chủ đề chờ đợi điều kiện này, nếu có. Nếu luồng cuộc gọi không có được khóa khi phương thức này được gọi, một 

maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
4 sẽ được nâng lên.

Phương pháp này thức dậy nhiều nhất n của các luồng đang chờ biến điều kiện; Đó là một không có nếu không có chủ đề đang chờ đợi.

Việc triển khai hiện tại thức dậy chính xác n chủ đề, nếu ít nhất n chủ đề đang chờ. Tuy nhiên, nó không an toàn để dựa vào hành vi này. Một tương lai, việc thực hiện tối ưu hóa đôi khi có thể thức dậy nhiều hơn n chủ đề.

Lưu ý: Một luồng đánh thức không thực sự quay lại từ cuộc gọi 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 của nó cho đến khi nó có thể làm lại khóa. Vì 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
15 không giải phóng khóa, nên người gọi của nó nên.

________ 261 [][]

Thức dậy tất cả các chủ đề đang chờ đợi điều kiện này. Phương pháp này hoạt động như 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
15, nhưng đánh thức tất cả các luồng chờ thay vì một. Nếu luồng cuộc gọi không có được khóa khi phương thức này được gọi, một 
maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
4 sẽ được nâng lên.

Phương pháp 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
64 là bí danh không dùng nữa cho phương pháp này.

Đối tượng semaphore

Đây là một trong những nguyên thủy đồng bộ hóa lâu đời nhất trong lịch sử khoa học máy tính, được phát minh bởi nhà khoa học máy tính đầu tiên của Hà Lan Edsger W. Dijkstra [ông đã sử dụng tên 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
65 và 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
66 thay vì 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 và 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64].

Một semaphore quản lý một bộ đếm nội bộ bị giảm bởi mỗi cuộc gọi 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 và được tăng lên bởi mỗi cuộc gọi 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64. Bộ đếm không bao giờ có thể xuống dưới 0; Khi 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 thấy rằng nó bằng không, nó sẽ chặn, chờ cho đến khi một số luồng khác gọi 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64.

Semaphores cũng hỗ trợ giao thức quản lý bối cảnh.context management protocol.

Lớp ________ 21 ________ 274 [Giá trị = 1] ¶[value=1]

Lớp này thực hiện các đối tượng Semaphore. Một semaphore quản lý một bộ đếm nguyên tử đại diện cho số lượng 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64 gọi trừ số lượng cuộc gọi 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63, cộng với giá trị ban đầu. Phương pháp 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 khối nếu cần thiết cho đến khi nó có thể quay lại mà không làm cho bộ đếm âm. Nếu không được đưa ra, giá trị mặc định là 1.

Đối số tùy chọn cho giá trị ban đầu cho bộ đếm nội bộ; Nó mặc định là 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
78. Nếu giá trị được đưa ra nhỏ hơn 0, 
maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
5 sẽ được nâng lên.

Thay đổi trong phiên bản 3.3: Thay đổi từ chức năng nhà máy sang một lớp.changed from a factory function to a class.

________ 176 [chặn = true, thời gian chờ = không] ¶[blocking=True, timeout=None]

Có được một semaphore.

Khi được gọi mà không có tranh luận:

  • Nếu bộ đếm bên trong lớn hơn 0 khi nhập, hãy giảm một và trả về 

    
def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
    48 ngay lập tức.

  • Nếu bộ đếm bên trong bằng không trên mục nhập, hãy chặn cho đến khi đánh thức bằng một cuộc gọi đến 

    
def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
    64. Sau khi đánh thức [và bộ đếm lớn hơn 0], giảm bộ đếm xuống 1 và trả về 
    
def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
    48. Chính xác một chủ đề sẽ bị đánh thức bởi mỗi cuộc gọi đến 
    
def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
    64. Thứ tự mà các chủ đề bị đánh thức không nên dựa vào.

Khi được gọi bằng chặn được đặt thành 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54, không chặn. Nếu một cuộc gọi không có đối số sẽ chặn, hãy trả lại 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54 ngay lập tức; Nếu không, hãy làm điều tương tự như khi được gọi mà không có đối số và trả lại 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48.

Khi được gọi với một thời gian chờ khác với 

mydata = threading.local[]
mydata.x = 1
4, nó sẽ chặn trong hầu hết các thời gian chờ. Nếu việc mua lại không hoàn thành thành công trong khoảng đó, hãy trả lại 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
54. Trả lại 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 nếu không.

Đã thay đổi trong phiên bản 3.2: Tham số thời gian chờ là mới.The timeout parameter is new.

________ 187 [n = 1][n=1]

Phát hành một semaphore, tăng bộ đếm nội bộ của n. Khi nó bằng không khi nhập và các chủ đề khác đang chờ nó trở nên lớn hơn 0 một lần nữa, hãy đánh thức n của các luồng đó.

Đã thay đổi trong phiên bản 3.9: Đã thêm tham số N để phát hành nhiều luồng chờ cùng một lúc.Added the n parameter to release multiple waiting threads at once.

Lớp ________ 21 ________ 293 [Giá trị = 1] ¶[value=1]

Lớp thực hiện các đối tượng semaphore bị ràng buộc. Một semaphore bị ràng buộc kiểm tra để đảm bảo giá trị hiện tại của nó không vượt quá giá trị ban đầu. Nếu có, 

maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
5 được nâng lên. Trong hầu hết các tình huống, Semaphores được sử dụng để bảo vệ các nguồn lực với năng lực hạn chế. Nếu semaphore được phát hành quá nhiều lần thì đó là một dấu hiệu của một lỗi. Nếu không được đưa ra, giá trị mặc định là 1.

Thay đổi trong phiên bản 3.3: Thay đổi từ chức năng nhà máy sang một lớp.changed from a factory function to a class.

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
95 Ví dụ En

Semaphores thường được sử dụng để bảo vệ các tài nguyên với công suất hạn chế, ví dụ, một máy chủ cơ sở dữ liệu. Trong mọi tình huống mà kích thước của tài nguyên được cố định, bạn nên sử dụng semaphore bị ràng buộc. Trước khi sinh sản bất kỳ luồng công nhân nào, chủ đề chính của bạn sẽ khởi tạo semaphore:

maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]

Sau khi sinh ra, các luồng công nhân gọi các phương thức thu nhận và phát hành Semaphore khi chúng cần kết nối với máy chủ:

with pool_sema:
    conn = connectdb[]
    try:
        # ... use connection ...
    finally:
        conn.close[]

Việc sử dụng một semaphore bị ràng buộc làm giảm khả năng lỗi lập trình khiến semaphore được giải phóng nhiều hơn so với nó có được sẽ không bị phát hiện.

Đối tượng sự kiện

Đây là một trong những cơ chế đơn giản nhất để giao tiếp giữa các luồng: một luồng báo hiệu một sự kiện và các luồng khác chờ đợi nó.

Một đối tượng sự kiện quản lý một lá cờ bên trong có thể được đặt thành True với phương thức 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
96 và đặt lại thành sai với phương thức 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
97. Phương thức 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 chặn cho đến khi cờ là đúng.

Lớp ________ 21 ________ 300¶

Lớp thực hiện các đối tượng sự kiện. Một sự kiện quản lý một lá cờ có thể được đặt thành True với phương thức 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
96 và đặt lại thành Sai với phương thức 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
97. Phương thức 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 chặn cho đến khi cờ là đúng. Cờ ban đầu là sai.

Thay đổi trong phiên bản 3.3: Thay đổi từ chức năng nhà máy sang một lớp.changed from a factory function to a class.

________ 304 [][]

Trả về 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 khi và chỉ khi cờ bên trong là đúng.

Phương pháp 

mydata = threading.local[]
mydata.x = 1
06 là bí danh không dùng nữa cho phương pháp này.

________ 307 [][]

Đặt cờ bên trong thành true. Tất cả các chủ đề đang chờ nó trở thành sự thật đều được đánh thức. Các luồng gọi 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 Một khi cờ là đúng sẽ không chặn được.

________ 309 [][]

Đặt lại cờ bên trong thành sai. Sau đó, các luồng gọi 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 sẽ chặn cho đến khi 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
96 được gọi để đặt cờ bên trong thành True một lần nữa.

________ 242 [thời gian chờ = Không] ¶[timeout=None]

Chặn cho đến khi cờ bên trong là đúng. Nếu cờ bên trong đúng khi nhập, hãy quay lại ngay lập tức. Mặt khác, chặn cho đến khi một luồng khác gọi 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
96 để đặt cờ thành true hoặc cho đến khi thời gian chờ tùy chọn xảy ra.

Khi đối số thời gian chờ có mặt chứ không phải 

mydata = threading.local[]
mydata.x = 1
4, nó sẽ là một số điểm nổi chỉ định thời gian chờ cho hoạt động tính bằng giây [hoặc phân số của chúng].

Phương thức này trả về 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 khi và chỉ khi cờ bên trong được đặt thành đúng, trước khi cuộc gọi chờ hoặc sau khi chờ đợi, do đó, nó sẽ luôn trả về 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 trừ khi hết thời gian chờ và hết thời gian hoạt động.

Đã thay đổi trong phiên bản 3.1: Trước đây, phương thức luôn được trả về 

mydata = threading.local[]
mydata.x = 1
4.Previously, the method always returned 
mydata = threading.local[]
mydata.x = 1
4.

Đối tượng hẹn giờ

Lớp này đại diện cho một hành động chỉ nên được chạy sau một khoảng thời gian nhất định đã trôi qua - một bộ đếm thời gian. 

mydata = threading.local[]
mydata.x = 1
18 là một lớp con của 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
3 và như vậy cũng có chức năng như một ví dụ về việc tạo các luồng tùy chỉnh.

Bộ định thời được bắt đầu, như với các chủ đề, bằng cách gọi phương thức 

def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed
1 của chúng. Bộ hẹn giờ có thể được dừng [trước khi hành động của nó đã bắt đầu] bằng cách gọi phương thức 
mydata = threading.local[]
mydata.x = 1
21. Khoảng thời gian của bộ hẹn giờ sẽ đợi trước khi thực hiện hành động của nó có thể không giống hệt như khoảng thời gian được chỉ định bởi người dùng.

Ví dụ:

def hello[]:
    print["hello, world"]

t = Timer[30.0, hello]
t.start[]  # after 30 seconds, "hello, world" will be printed

Lớp ________ 21 ________ 323 [khoảng, hàm, args = none, kwargs = none] ¶[interval, function, args=None, kwargs=None]

Tạo một bộ đếm thời gian sẽ chạy chức năng với các đối số tranh luận và từ khóa đối số kwargs, sau khi khoảng giây đã trôi qua. Nếu Args là 

mydata = threading.local[]
mydata.x = 1
4 [mặc định] thì một danh sách trống sẽ được sử dụng. Nếu kwargs là 
mydata = threading.local[]
mydata.x = 1
4 [mặc định] thì một dict trống sẽ được sử dụng.

Thay đổi trong phiên bản 3.3: Thay đổi từ chức năng nhà máy sang một lớp.changed from a factory function to a class.

________ 326 [][]

Dừng bộ đếm thời gian và hủy bỏ việc thực hiện hành động hẹn giờ. Điều này sẽ chỉ hoạt động nếu bộ đếm thời gian vẫn đang trong giai đoạn chờ đợi.

Đối tượng rào cản

Mới trong phiên bản 3.2.

Lớp này cung cấp một nguyên thủy đồng bộ hóa đơn giản để sử dụng bởi một số lượng cố định các luồng cần phải đợi nhau. Mỗi luồng cố gắng vượt qua rào cản bằng cách gọi phương thức 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 và sẽ chặn cho đến khi tất cả các luồng đã thực hiện các cuộc gọi 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 của họ. Tại thời điểm này, các chủ đề được phát hành đồng thời.

Rào cản có thể được sử dụng lại bất kỳ số lần cho cùng một số lượng chủ đề.

Ví dụ, đây là một cách đơn giản để đồng bộ hóa luồng máy khách và máy chủ:


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
0

Lớp ________ 21 ________ 330 [bên, hành động = không, thời gian chờ = Không] ¶[parties, action=None, timeout=None]

Tạo một đối tượng rào cản cho các bên số lượng chủ đề. Một hành động, khi được cung cấp, là một cuộc gọi được gọi để được gọi bởi một trong các chủ đề khi chúng được phát hành. Thời gian chờ là giá trị thời gian chờ mặc định nếu không có gì được chỉ định cho phương thức 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14.

________ 242 [thời gian chờ = Không] ¶[timeout=None]

Chặn cho đến khi cờ bên trong là đúng. Nếu cờ bên trong đúng khi nhập, hãy quay lại ngay lập tức. Mặt khác, chặn cho đến khi một luồng khác gọi 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
96 để đặt cờ thành true hoặc cho đến khi thời gian chờ tùy chọn xảy ra.

Giá trị trả về là một số nguyên trong phạm vi 0 đến các bên - 1, khác nhau cho mỗi luồng. Điều này có thể được sử dụng để chọn một chủ đề để thực hiện một số công việc dọn phòng đặc biệt, ví dụ:


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
1

Nếu một hành động được cung cấp cho hàm tạo, một trong các luồng sẽ gọi nó trước khi được phát hành. Nếu cuộc gọi này gây ra lỗi, rào cản được đưa vào trạng thái bị hỏng.

Nếu cuộc gọi hết thời gian, rào cản được đưa vào trạng thái bị hỏng.

Phương pháp này có thể tăng ngoại lệ 

mydata = threading.local[]
mydata.x = 1
33 nếu rào cản bị hỏng hoặc đặt lại trong khi một luồng đang chờ.

________ 334 [][]

Trả hàng rào cho trạng thái mặc định, trống. Bất kỳ chủ đề đang chờ đợi trên nó sẽ nhận được ngoại lệ 

mydata = threading.local[]
mydata.x = 1
33.

Lưu ý rằng sử dụng chức năng này có thể yêu cầu một số đồng bộ hóa bên ngoài nếu có các luồng khác mà trạng thái không rõ. Nếu một rào cản bị phá vỡ, có thể tốt hơn là chỉ để nó và tạo ra một cái mới.

________ 336 [][]

Đặt rào cản vào một trạng thái bị hỏng. Điều này khiến mọi cuộc gọi hoạt động hoặc trong tương lai đến 

def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
14 thất bại với 
mydata = threading.local[]
mydata.x = 1
33. Sử dụng điều này ví dụ nếu một trong các chủ đề cần hủy bỏ, để tránh giảm ứng dụng.

Có thể tốt hơn là chỉ cần tạo ra hàng rào với giá trị thời gian chờ hợp lý để tự động bảo vệ chống lại một trong các luồng sẽ bị đánh giá cao.

________ 339¶

Số lượng chủ đề cần thiết để vượt qua hàng rào.

________ 340¶

Số lượng chủ đề hiện đang chờ đợi trong rào cản.

________ 341¶

Một boolean là 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
48 nếu rào cản ở trạng thái bị hỏng.

Ngoại lệ ________ 21 ________ 344¶

Ngoại lệ này, một lớp con của 

maxconnections = 5
# ...
pool_sema = BoundedSemaphore[value=maxconnections]
4, được nâng lên khi đối tượng 
mydata = threading.local[]
mydata.x = 1
46 được đặt lại hoặc bị hỏng.

Sử dụng khóa, điều kiện và semaphores trong Tuyên bố 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
11

Tất cả các đối tượng được cung cấp bởi mô -đun này có các phương thức 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 và 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64 có thể được sử dụng làm Trình quản lý ngữ cảnh cho câu lệnh 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
11. Phương pháp 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
63 sẽ được gọi khi khối được nhập và 

def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
64 sẽ được gọi khi khối được thoát. Do đó, đoạn trích sau:


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
2

tương đương với:


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
3

Hiện tại, 


def frame_thread[url, dire, i]:
    global camera_reconnection, video_retrieval_status
    cap = cv2.VideoCapture[url]
    ret = cap.set[3, 768]
    ret = cap.set[4, 432]
    if not os.path.exists[name + dire]:
        os.mkdir[name + dire]
    for x in os.listdir[name+dire]:
        items[i].append[x]
    items[i].sort[]
    for k in items[i]:
        q2[i].append[os.path.join[name+dire, k]]
    while cap.isOpened[]:
        if camera_reconnection[i]:
            cap = cv2.VideoCapture[url]
            last_frame[i] = False
            camera_reconnection[i] = False
        if last_frame[i] is False:
            start_time = time.time[]
            ret, frame = cap.read[]
            if ret:
                video_file = os.path.join[name + dire, str[time.strftime['%H %M %S']]+".avi"]
                q2[i].append[video_file]
                if len[q2[i]] > int[video_save]:
                    data = q2[i].popleft[]
                    os.remove[data]
                video_writer = cv2.VideoWriter[video_file, video_codec, fps, [int[cap.get[3]], int[cap.get[4]]]]
                while[int[time.time[] - start_time]] < video_duration:
                    ret, frame = cap.read[]
                    if not ret:
                        last_frame[i] = True
                        video_writer.release[]
                        cv2.destroyAllWindows[]
                        break
                    video_writer.write[frame]
                video_writer.release[]
                if[video_retrieval_status[i] == VIDEO_LIST_RETRIEVAL_SPECIFIC_START]:
                    video_retrieval_status[i] = VIDEO_LIST_RETRIEVAL_SPECIFIC_READY
75, 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
00, 
mydata = threading.local[]
mydata.x = 1
55, 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
95 và 
mydata = threading.local[]
mydata.x = 1
57 Các đối tượng có thể được sử dụng làm Trình quản lý bối cảnh câu lệnh 
def retrieve_thread[streamk, k]:
    global video_retrieval_status
    print["dbg0", flush=True]
    if[video_retrieval_status[k] == NO_RETRIEVAL]:
        print["dbg1", flush=True]
    else:
        print["dbg2", flush=True]

        if [video_retrieval_status[k] == VIDEO_LIST_RETRIEVAL_SPECIFIC_READY]:
            print["dbg3", flush=True]
            post_storage_retrieval_specific[k]
            print["dbg4", flush=True]
            video_retrieval_status[k] = NO_RETRIEVAL
11.

Các chủ đề python có chạy đồng thời không?

Trên thực tế, một quá trình Python không thể chạy các luồng song song nhưng nó có thể chạy chúng đồng thời thông qua chuyển đổi ngữ cảnh trong các hoạt động ràng buộc I/O. Hạn chế này thực sự được thực thi bởi Gil. Khóa thông dịch viên toàn cầu Python [GIL] ngăn chặn các luồng trong cùng một quy trình được thực hiện cùng một lúc.it can run them concurrently through context switching during I/O bound operations. This limitation is actually enforced by GIL. The Python Global Interpreter Lock [GIL] prevents threads within the same process to be executed at the same time.

Tôi có thể chạy bao nhiêu chủ đề python?

Mỗi lõi CPU có thể có tối đa hai luồng nếu CPU của bạn có kích hoạt đa/siêu luồng.Bạn có thể tìm kiếm bộ xử lý CPU của riêng bạn để tìm hiểu thêm.Đối với người dùng Mac, bạn có thể tìm hiểu từ Giới thiệu> Báo cáo hệ thống.Điều này có nghĩa là bộ xử lý i7 6 lõi của tôi có 6 lõi và có thể có tối đa 12 luồng.. You can search for your own CPU processor to find out more. For Mac users, you can find out from About > System Report. This means that my 6-Core i7 processor has 6 cores and can have up to 12 threads.

Python có thực sự đa luồng không?

Python không hỗ trợ đa luồng vì Python trên trình thông dịch Cpython không hỗ trợ thực thi đa lõi thực sự thông qua đa luồng.Tuy nhiên, Python có một thư viện luồng.Gil không ngăn chặn luồng. because Python on the Cpython interpreter does not support true multi-core execution via multithreading. However, Python does have a threading library. The GIL does not prevent threading.

Sự khác biệt giữa khóa luồng và rlock luồng là gì?

Một đối tượng khóa không thể có được lại bởi bất kỳ luồng nào trừ khi nó được phát hành bởi luồng đang truy cập vào tài nguyên được chia sẻ. Đối tượng rlock có thể được thu thập nhiều lần bởi bất kỳ luồng nào.Một đối tượng khóa có thể được phát hành bởi bất kỳ chủ đề.Một đối tượng rlock chỉ có thể được phát hành bởi luồng có được nó. An RLock object can be acquired numerous times by any thread. A Lock object can be released by any thread. An RLock object can only be released by the thread which acquired it.

Bài Viết Liên Quan

Hướng dẫn dùng flower pfp trong PHP
Hướng dẫn how to delete selected cells in excel shortcut - cách xóa các ô đã chọn trong phím tắt excel
Hướng dẫn live video broadcasting in php - phát video trực tiếp bằng php
Hướng dẫn matlab vs python engineering - matlab và kỹ thuật python
Hướng dẫn how do you count occurrences in javascript? - làm thế nào để bạn đếm số lần xuất hiện trong javascript?
Hướng dẫn income tax calculator php script - tập lệnh php tính thuế thu nhập
Hướng dẫn python simulation example - ví dụ mô phỏng python
Hướng dẫn what is whitespace in python example? - khoảng trắng trong ví dụ python là gì?
Hướng dẫn php interface properties - thuộc tính giao diện php
Is Dodge discontinuing the Hellcat in 2023?
Hướng dẫn hollow right angled triangle in python using for loop - tam giác vuông góc rỗng trong python sử dụng vòng lặp for
Hướng dẫn html to pdf javascript - html sang pdf javascript
Hướng dẫn python decorator - trang trí trăn
Hướng dẫn 8 bit int in python - 8 bit int trong python
Hướng dẫn write multiple lines to csv file python - ghi nhiều dòng vào tệp csv python
Hướng dẫn import html2canvas - nhập html2canvas
Hướng dẫn built-in data types in python - các kiểu dữ liệu tích hợp trong python
Hướng dẫn dùng f_gets trong PHP
Hướng dẫn dùng file type python
Hướng dẫn how to protect web pages in javascript mcq - cách bảo vệ các trang web trong javascript mcq

Toplist mới

#1
Top 7 sự tích hồ gươm - ngữ văn lớp 6 2023
6 tháng trước
#2
Top 7 gdcd 6 bài 1 kết nối tri thức 2023
6 tháng trước
#3
Top 7 ý nghĩa của xây dựng gia đình văn hóa 2023
6 tháng trước
#4
Top 6 mẫu hợp đồng mượn đất làm nhà xưởng 2023
6 tháng trước
#5
Top 3 tổng tài biến thái tôi yêu anh tập 27 2023
6 tháng trước
#6
Top 6 kết thực phim mỹ nhân vô lệ 2023
6 tháng trước
#7
Top 9 trong những câu thơ sau câu nào sử dụng thành ngữ 2023
6 tháng trước
#8
Top 8 đề tài và chủ de của tác phẩm tắt đèn 2023
6 tháng trước
#9
Top 5 tiểu sử của thầy thích pháp hòa 2023
6 tháng trước

Bài mới nhất

Hạt giống nguyên chủng là gì năm 2024
De thi học kì 1 hóa 9 tphcm năm 2024
Phục hồi nút erase trong cs6 bị lỗi năm 2024
Nhung loai rau cu tot cho gan và tiên hóa năm 2024
Dì ruột bán cháu ở thường xuân thanh hóa năm 2024
Thu nhập trung bình của quản lý nhà hàng năm 2024
Kiến bu quần lót là hiện tượng gì năm 2024

Chủ Đề

programming Hỏi Đáp Toplist Là gì Bài Tập Địa Điểm Hay Mẹo Hay Học Tốt Nghĩa của từ Công Nghệ Khỏe Đẹp bao nhiêu Top List Tiếng anh Bao nhiêu Sản phẩm tốt Xây Đựng Ngôn ngữ javascript Ở đâu Đại học Hướng dẫn Bài tập Tại sao Dịch So Sánh Máy tính Món Ngon mẹo hay Bao lâu Thế nào So sánh Khoa Học Vì sao Lớp 9 Lớp 10