Danh sách python loại bỏ chủ đề an toàn

Gọi

from threading import Thread
import time

# all threads can access this global variable
database_value = 0

def increase():
    global database_value # needed to modify the global value

    # get a local copy (simulate data retrieving)
    local_copy = database_value

    # simulate some modifying operation
    local_copy += 1
    time.sleep(0.1)

    # write the calculated new value into the global variable
    database_value = local_copy


if __name__ == "__main__":

    print('Start value: ', database_value)

    t1 = Thread(target=increase)
    t2 = Thread(target=increase)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    print('End value:', database_value)

    print('end main')

from threading import Thread

def square_numbers():
    for i in range(1000):
        result = i * i


if __name__ == "__main__":        
    threads = []
    num_threads = 10

    # create threads and asign a function for each thread
    for i in range(num_threads):
        thread = Thread(target=square_numbers)
        threads.append(thread)

    # start all threads
    for thread in threads:
        thread.start()

    # wait for all threads to finish
    # block the main thread until these threads are finished
    for thread in threads:
        thread.join()

Chia sẻ dữ liệu giữa các luồng

Vì các luồng nằm trong cùng một không gian bộ nhớ nên chúng có quyền truy cập vào cùng một dữ liệu (công khai). Vì vậy, ví dụ, bạn có thể chỉ cần sử dụng một biến toàn cục mà tất cả các luồng có quyền truy cập đọc và ghi

Nhiệm vụ. Tạo hai luồng, mỗi luồng sẽ truy cập giá trị cơ sở dữ liệu hiện tại, sửa đổi nó (trong trường hợp này chỉ tăng giá trị đó lên 1) và ghi lại giá trị mới vào giá trị cơ sở dữ liệu. Mỗi luồng nên thực hiện thao tác này 10 lần

from threading import Thread
import time

# all threads can access this global variable
database_value = 0

def increase():
    global database_value # needed to modify the global value

    # get a local copy (simulate data retrieving)
    local_copy = database_value

    # simulate some modifying operation
    local_copy += 1
    time.sleep(0.1)

    # write the calculated new value into the global variable
    database_value = local_copy


if __name__ == "__main__":

    print('Start value: ', database_value)

    t1 = Thread(target=increase)
    t2 = Thread(target=increase)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    print('End value:', database_value)

    print('end main')

Start value:  0
End value: 1
end main

Cách sử dụng from threading import Thread import time # all threads can access this global variable database_value = 0 def increase(): global database_value # needed to modify the global value # get a local copy (simulate data retrieving) local_copy = database_value # simulate some modifying operation local_copy += 1 time.sleep(0.1) # write the calculated new value into the global variable database_value = local_copy if __name__ == "__main__": print('Start value: ', database_value) t1 = Thread(target=increase) t2 = Thread(target=increase) t1.start() t2.start() t1.join() t2.join() print('End value:', database_value) print('end main') 1

Lưu ý rằng trong ví dụ trên, 2 luồng sẽ tăng giá trị lên 1, vì vậy 2 thao tác tăng được thực hiện. Nhưng tại sao giá trị cuối cùng là 1 chứ không phải 2?

Điều kiện của cuộc đua

Một điều kiện cuộc đua đã xảy ra ở đây. Tình trạng dồn đuổi xảy ra khi hai hoặc nhiều luồng có thể truy cập dữ liệu được chia sẻ và chúng cố gắng thay đổi dữ liệu đó cùng một lúc. Vì thuật toán lập lịch luồng có thể hoán đổi giữa các luồng bất kỳ lúc nào, nên bạn không biết thứ tự các luồng sẽ cố gắng truy cập dữ liệu được chia sẻ. Trong trường hợp của chúng tôi, chuỗi đầu tiên truy cập vào

from threading import Thread
import time

# all threads can access this global variable
database_value = 0

def increase():
    global database_value # needed to modify the global value

    # get a local copy (simulate data retrieving)
    local_copy = database_value

    # simulate some modifying operation
    local_copy += 1
    time.sleep(0.1)

    # write the calculated new value into the global variable
    database_value = local_copy


if __name__ == "__main__":

    print('Start value: ', database_value)

    t1 = Thread(target=increase)
    t2 = Thread(target=increase)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    print('End value:', database_value)

    print('end main')

Start value:  0
End value: 1
end main

Start value:  0
End value: 1
end main

from threading import Thread
import time

# all threads can access this global variable
database_value = 0

def increase():
    global database_value # needed to modify the global value

    # get a local copy (simulate data retrieving)
    local_copy = database_value

    # simulate some modifying operation
    local_copy += 1
    time.sleep(0.1)

    # write the calculated new value into the global variable
    database_value = local_copy


if __name__ == "__main__":

    print('Start value: ', database_value)

    t1 = Thread(target=increase)
    t2 = Thread(target=increase)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    print('End value:', database_value)

    print('end main')

Start value:  0
End value: 1
end main

from threading import Thread
import time

# all threads can access this global variable
database_value = 0

def increase():
    global database_value # needed to modify the global value

    # get a local copy (simulate data retrieving)
    local_copy = database_value

    # simulate some modifying operation
    local_copy += 1
    time.sleep(0.1)

    # write the calculated new value into the global variable
    database_value = local_copy


if __name__ == "__main__":

    print('Start value: ', database_value)

    t1 = Thread(target=increase)
    t2 = Thread(target=increase)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    print('End value:', database_value)

    print('end main')

Tránh các điều kiện cuộc đua với from threading import Thread import time # all threads can access this global variable database_value = 0 def increase(): global database_value # needed to modify the global value # get a local copy (simulate data retrieving) local_copy = database_value # simulate some modifying operation local_copy += 1 time.sleep(0.1) # write the calculated new value into the global variable database_value = local_copy if __name__ == "__main__": print('Start value: ', database_value) t1 = Thread(target=increase) t2 = Thread(target=increase) t1.start() t2.start() t1.join() t2.join() print('End value:', database_value) print('end main') 1

Khóa (còn được gọi là mutex) là một cơ chế đồng bộ hóa để thực thi các giới hạn đối với quyền truy cập vào tài nguyên trong môi trường có nhiều luồng thực thi. Khóa có hai trạng thái. bị khóa và mở khóa. Nếu trạng thái bị khóa, nó không cho phép các luồng khác đồng thời vào phần mã này cho đến khi trạng thái được mở khóa trở lại

Hai chức năng quan trọng. -

Start value:  0
End value: 1
end main

Start value:  0
End value: 1
end main

Quan trọng. Bạn phải luôn giải phóng lại khối sau khi có được nó

Trong ví dụ của chúng tôi, phần mã quan trọng nơi các giá trị cơ sở dữ liệu được truy xuất và sửa đổi hiện đã bị khóa. Điều này ngăn luồng thứ hai sửa đổi dữ liệu chung cùng một lúc. Không có nhiều thay đổi trong mã của chúng tôi. Tất cả các thay đổi mới được nhận xét trong mã bên dưới

from threading import Thread

def square_numbers():
    for i in range(1000):
        result = i * i


if __name__ == "__main__":        
    threads = []
    num_threads = 10

    # create threads and asign a function for each thread
    for i in range(num_threads):
        thread = Thread(target=square_numbers)
        threads.append(thread)

    # start all threads
    for thread in threads:
        thread.start()

    # wait for all threads to finish
    # block the main thread until these threads are finished
    for thread in threads:
        thread.join()

from threading import Thread

def square_numbers():
    for i in range(1000):
        result = i * i


if __name__ == "__main__":        
    threads = []
    num_threads = 10

    # create threads and asign a function for each thread
    for i in range(num_threads):
        thread = Thread(target=square_numbers)
        threads.append(thread)

    # start all threads
    for thread in threads:
        thread.start()

    # wait for all threads to finish
    # block the main thread until these threads are finished
    for thread in threads:
        thread.join()

Sử dụng khóa làm trình quản lý ngữ cảnh

Sau

Start value:  0
End value: 1
end main

Start value:  0
End value: 1
end main

from threading import Thread

def square_numbers():
    for i in range(1000):
        result = i * i


if __name__ == "__main__":        
    threads = []
    num_threads = 10

    # create threads and asign a function for each thread
    for i in range(num_threads):
        thread = Thread(target=square_numbers)
        threads.append(thread)

    # start all threads
    for thread in threads:
        thread.start()

    # wait for all threads to finish
    # block the main thread until these threads are finished
    for thread in threads:
        thread.join()

Sử dụng hàng đợi trong Python

Hàng đợi có thể được sử dụng để trao đổi dữ liệu an toàn luồng/an toàn quy trình và xử lý dữ liệu cả trong môi trường đa luồng và đa xử lý

hàng đợi

Hàng đợi là một cấu trúc dữ liệu tuyến tính tuân theo nguyên tắc Nhập trước xuất trước (FIFO). Một ví dụ điển hình là một hàng khách đang xếp hàng chờ đợi, trong đó khách hàng đến trước được phục vụ trước.

from threading import Thread

def square_numbers():
    for i in range(1000):
        result = i * i


if __name__ == "__main__":        
    threads = []
    num_threads = 10

    # create threads and asign a function for each thread
    for i in range(num_threads):
        thread = Thread(target=square_numbers)
        threads.append(thread)

    # start all threads
    for thread in threads:
        thread.start()

    # wait for all threads to finish
    # block the main thread until these threads are finished
    for thread in threads:
        thread.join()

from threading import Thread
import time

# all threads can access this global variable
database_value = 0

def increase():
    global database_value # needed to modify the global value

    # get a local copy (simulate data retrieving)
    local_copy = database_value

    # simulate some modifying operation
    local_copy += 1
    time.sleep(0.1)

    # write the calculated new value into the global variable
    database_value = local_copy


if __name__ == "__main__":

    print('Start value: ', database_value)

    t1 = Thread(target=increase)
    t2 = Thread(target=increase)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    print('End value:', database_value)

    print('end main')

Sử dụng hàng đợi trong đa luồng

Các hoạt động với một hàng đợi là luồng an toàn. Các phương pháp quan trọng là

• from threading import Thread
  
  def square_numbers():
      for i in range(1000):
          result = i * i
  
  
  if __name__ == "__main__":        
      threads = []
      num_threads = 10
  
      # create threads and asign a function for each thread
      for i in range(num_threads):
          thread = Thread(target=square_numbers)
          threads.append(thread)
  
      # start all threads
      for thread in threads:
          thread.start()
  
      # wait for all threads to finish
      # block the main thread until these threads are finished
      for thread in threads:
          thread.join()
  

  40. Xóa và trả lại mục đầu tiên. Theo mặc định, nó chặn cho đến khi có mặt hàng

• from threading import Thread
  
  def square_numbers():
      for i in range(1000):
          result = i * i
  
  
  if __name__ == "__main__":        
      threads = []
      num_threads = 10
  
      # create threads and asign a function for each thread
      for i in range(num_threads):
          thread = Thread(target=square_numbers)
          threads.append(thread)
  
      # start all threads
      for thread in threads:
          thread.start()
  
      # wait for all threads to finish
      # block the main thread until these threads are finished
      for thread in threads:
          thread.join()
  

  41. Đặt phần tử ở cuối hàng đợi. Theo mặc định, nó sẽ chặn cho đến khi có một vị trí miễn phí

• from threading import Thread
  
  def square_numbers():
      for i in range(1000):
          result = i * i
  
  
  if __name__ == "__main__":        
      threads = []
      num_threads = 10
  
      # create threads and asign a function for each thread
      for i in range(num_threads):
          thread = Thread(target=square_numbers)
          threads.append(thread)
  
      # start all threads
      for thread in threads:
          thread.start()
  
      # wait for all threads to finish
      # block the main thread until these threads are finished
      for thread in threads:
          thread.join()
  

  42. Chỉ ra rằng một nhiệm vụ được xử lý trước đây đã hoàn thành. Đối với mỗi

  from threading import Thread
  
  def square_numbers():
      for i in range(1000):
          result = i * i
  
  
  if __name__ == "__main__":        
      threads = []
      num_threads = 10
  
      # create threads and asign a function for each thread
      for i in range(num_threads):
          thread = Thread(target=square_numbers)
          threads.append(thread)
  
      # start all threads
      for thread in threads:
          thread.start()
  
      # wait for all threads to finish
      # block the main thread until these threads are finished
      for thread in threads:
          thread.join()
  

  43, bạn nên gọi nó sau khi bạn hoàn thành nhiệm vụ của mình cho mục này

• from threading import Thread
  
  def square_numbers():
      for i in range(1000):
          result = i * i
  
  
  if __name__ == "__main__":        
      threads = []
      num_threads = 10
  
      # create threads and asign a function for each thread
      for i in range(num_threads):
          thread = Thread(target=square_numbers)
          threads.append(thread)
  
      # start all threads
      for thread in threads:
          thread.start()
  
      # wait for all threads to finish
      # block the main thread until these threads are finished
      for thread in threads:
          thread.join()
  

  44. Chặn cho đến khi tất cả các mục trong hàng đợi đã được nhận và xử lý (

  from threading import Thread
  
  def square_numbers():
      for i in range(1000):
          result = i * i
  
  
  if __name__ == "__main__":        
      threads = []
      num_threads = 10
  
      # create threads and asign a function for each thread
      for i in range(num_threads):
          thread = Thread(target=square_numbers)
          threads.append(thread)
  
      # start all threads
      for thread in threads:
          thread.start()
  
      # wait for all threads to finish
      # block the main thread until these threads are finished
      for thread in threads:
          thread.join()
  

  45 đã được gọi cho mỗi mục)

• from threading import Thread
  
  def square_numbers():
      for i in range(1000):
          result = i * i
  
  
  if __name__ == "__main__":        
      threads = []
      num_threads = 10
  
      # create threads and asign a function for each thread
      for i in range(num_threads):
          thread = Thread(target=square_numbers)
          threads.append(thread)
  
      # start all threads
      for thread in threads:
          thread.start()
  
      # wait for all threads to finish
      # block the main thread until these threads are finished
      for thread in threads:
          thread.join()
  

  46. Trả về True nếu hàng đợi rỗng

Ví dụ sau sử dụng hàng đợi để trao đổi số từ 0. 19. Mỗi luồng gọi phương thức

from threading import Thread

def square_numbers():
    for i in range(1000):
        result = i * i


if __name__ == "__main__":        
    threads = []
    num_threads = 10

    # create threads and asign a function for each thread
    for i in range(num_threads):
        thread = Thread(target=square_numbers)
        threads.append(thread)

    # start all threads
    for thread in threads:
        thread.start()

    # wait for all threads to finish
    # block the main thread until these threads are finished
    for thread in threads:
        thread.join()

from threading import Thread

def square_numbers():
    for i in range(1000):
        result = i * i


if __name__ == "__main__":        
    threads = []
    num_threads = 10

    # create threads and asign a function for each thread
    for i in range(num_threads):
        thread = Thread(target=square_numbers)
        threads.append(thread)

    # start all threads
    for thread in threads:
        thread.start()

    # wait for all threads to finish
    # block the main thread until these threads are finished
    for thread in threads:
        thread.join()

from threading import Thread

def square_numbers():
    for i in range(1000):
        result = i * i


if __name__ == "__main__":        
    threads = []
    num_threads = 10

    # create threads and asign a function for each thread
    for i in range(num_threads):
        thread = Thread(target=square_numbers)
        threads.append(thread)

    # start all threads
    for thread in threads:
        thread.start()

    # wait for all threads to finish
    # block the main thread until these threads are finished
    for thread in threads:
        thread.join()

from threading import Thread

def square_numbers():
    for i in range(1000):
        result = i * i


if __name__ == "__main__":        
    threads = []
    num_threads = 10

    # create threads and asign a function for each thread
    for i in range(num_threads):
        thread = Thread(target=square_numbers)
        threads.append(thread)

    # start all threads
    for thread in threads:
        thread.start()

    # wait for all threads to finish
    # block the main thread until these threads are finished
    for thread in threads:
        thread.join()

Start value:  0
End value: 1
end main

Start value:  0
End value: 1
end main

chủ đề daemon

Trong ví dụ trên, daemon thread được sử dụng. Các luồng daemon là các luồng nền tự động chết khi chương trình chính kết thúc. Đây là lý do tại sao có thể thoát khỏi các vòng lặp vô hạn bên trong các phương thức worker. Nếu không có quy trình daemon, chúng tôi sẽ phải sử dụng cơ chế báo hiệu, chẳng hạn như

from threading import Thread

def square_numbers():
    for i in range(1000):
        result = i * i


if __name__ == "__main__":        
    threads = []
    num_threads = 10

    # create threads and asign a function for each thread
    for i in range(num_threads):
        thread = Thread(target=square_numbers)
        threads.append(thread)

    # start all threads
    for thread in threads:
        thread.start()

    # wait for all threads to finish
    # block the main thread until these threads are finished
    for thread in threads:
        thread.join()

Là danh sách trong chủ đề Python

Là chủ đề pop danh sách Python

Là chủ đề danh sách

Tại sao danh sách không phải là chủ đề