import threading
import time

def worker():
    """thread worker function"""
    print('Worker')
    time.sleep(5)
    print('Worker finished')

# create a new thread
t = threading.Thread(target=worker)

# start the thread
t.start()

# main thread continues execution
print('Main thread')

# wait for the worker thread to complete
t.join()

# main thread continues execution after worker thread completes
print('Main thread finished')

import threading

counter = 0

def increment():
    global counter
    lock.acquire()
    counter += 1
    lock.release()

lock = threading.Lock()

t1 = threading.Thread(target=increment)
t2 = threading.Thread(target=increment)
t1.start()
t2.start()
t1.join()
t2.join()

print(counter)

import threading
import queue
import time

class DataFetcherThread(threading.Thread):
    """Thread class for fetching data from a remote API"""
    def __init__ (self, queue, api_url):
        threading.Thread. __init__ (self)
        self.queue = queue
        self.api_url = api_url

    def run(self):
        while True:
            # fetch data from the API
            data = fetch_data_from_api(self.api_url)

            # put the data in the queue
            self.queue.put(data)

            # sleep for a short period of time
            time.sleep(5)

class DataProcessorThread(threading.Thread):
    """Thread class for processing data"""
    def __init__ (self, queue):
        threading.Thread. __init__ (self)
        self.queue = queue

    def run(self):
        while True:
            # get data from the queue
            data = self.queue.get()

            # process the data
            processed_data = process_data(data)

            # do something with the processed data
            save_to_database(processed_data)

            # signal that the data has been processed
            self.queue.task_done()

def fetch_data_from_api(api_url):
    """Function to fetch data from a remote API"""
    # code to fetch data from the API
    pass

def process_data(data):
    """Function to process data"""
    # code to process data
    pass

def save_to_database(processed_data):
    """Function to save data to a database"""
    # code to save data to the database
    pass

# create a queue to hold the data
data_queue = queue.Queue()

# create the fetcher and processor threads
fetcher = DataFetcherThread(data_queue, 'https://example.com/api')
processor = DataProcessorThread(data_queue)

# start the threads
fetcher.start()
processor.start()

# wait for the threads to complete
data_queue.join()

import threading
import time

counter = 0

def increment():
    global counter
    lock.acquire()
    counter += 1
    lock.release()

# Create a reentrant lock
lock = threading.RLock()

# Create a semaphore with a maximum capacity of 3
semaphore = threading.Semaphore(3)

# Create a barrier with a capacity of 4
barrier = threading.Barrier(4)

def worker1():
    """Thread worker function 1"""
    global counter
    semaphore.acquire()
    increment()
    print('Worker 1:', counter)
    time.sleep(1)
    semaphore.release()
    barrier.wait()

def worker2():
    """Thread worker function 2"""
    global counter
    semaphore.acquire()
    increment()
    print('Worker 2:', counter)
    time.sleep(1)
    semaphore.release()
    barrier.wait()

def worker3():
    """Thread worker function 3"""
    global counter
    semaphore.acquire()
    increment()
    print('Worker 3:', counter)
    time.sleep(1)
    semaphore.release()
    barrier.wait()

def worker4():
    """Thread worker function 4"""
    global counter
    semaphore.acquire()
    increment()
    print('Worker 4:', counter)
    time.sleep(1)
    semaphore.release()
    barrier.wait()

# create 4 threads
t1 = threading.Thread(target=worker1)
t2 = threading.Thread(target=worker2)
t3 = threading.Thread(target=worker3)
t4 = threading.Thread(target=worker4)

# start the threads
t1.start()
t2.start()
t3.start()
t4.start()

# wait for the threads to complete
t1.join()
t2.join()
t3.join()
t4.join()

print('Counter:', counter)

import concurrent.futures

def long_running_task(n):
    return n*n

with concurrent.futures.ThreadPoolExecutor() as executor:
    results = [executor.submit(long_running_task, i) for i in range(10)]

    for f in concurrent.futures.as_completed(results):
        print(f.result())

import concurrent.futures

def long_running_task(n):
    return n*n

with concurrent.futures.ProcessPoolExecutor() as executor:
    results = [executor.submit(long_running_task, i) for i in range(10)]

    for f in concurrent.futures.as_completed(results):
        print(f.result())

import concurrent.futures
import os
import time

def long_running_task(n):
    print(f"Task {n} is running on process {os.getpid()}")
    time.sleep(1)
    return n * n

def callback_function(future):
    result = future.result()
    print(f"Result {result} was generated by process {os.getpid()}")

with concurrent.futures.ProcessPoolExecutor() as executor:
    results = [executor.submit(long_running_task, i) for i in range(10)]

    # Add a callback to be called when a future is done
    for result in results:
        result.add_done_callback(callback_function)

print(f"Main process {os.getpid()}")

with concurrent.futures.ThreadPoolExecutor() as executor:
    results = [executor.submit(long_running_task, i) for i in range(10)]

    # Add a callback to be called when a future is done
    for result in results:
        result.add_done_callback(callback_function)

print(f"Main process {os.getpid()}")

import asyncio

async def long_running_task(n):
    print(f"Task {n} started")
    await asyncio.sleep(1)
    print(f"Task {n} finished")
    return n * n

async def main():
    tasks = [long_running_task(i) for i in range(10)]
    completed, pending = await asyncio.wait(tasks)
    for task in completed:
        print(task.result())

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

import asyncio

async def long_running_task(n):
    print(f"Task {n} started")
    await asyncio.sleep(1)
    print(f"Task {n} finished")
    return n * n

async def main():
    results = await asyncio.gather(*(long_running_task(i) for i in range(10)))
    for result in results:
        print(result)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

import asyncio

async def long_running_task(n):
    print(f"Task {n} started")
    await asyncio.sleep(1)
    print(f"Task {n} finished")
    return n * n

async def main():
    semaphore = asyncio.Semaphore(3)
    tasks = [long_running_task_with_semaphore(semaphore, i) for i in range(10)]
    completed, pending = await asyncio.wait(tasks)
    for task in completed:
        print(task.result())

async def long_running_task_with_semaphore(semaphore, n):
    async with semaphore:
        return await long_running_task(n)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())