chapter-7/chapter-7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "362b510a-305c-4e3a-b372-763ef70c9002",
   "metadata": {},
   "source": [
    "# Google Colab Rust Setup\n",
    "\n",
    "The following cell is used to set up and spin up a Jupyter Notebook environment with a Rust kernel using Nix and IPC Proxy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6e95668-1a86-456a-9896-f7a97e30f450",
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget -qO- https://gist.github.com/wiseaidev/2af6bef753d48565d11bcd478728c979/archive/3f6df40db09f3517ade41997b541b81f0976c12e.tar.gz | tar xvz --strip-components=1\n",
    "!bash setup_evcxr_kernel.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60c8d72c-b011-4360-b368-d540b8d7361a",
   "metadata": {},
   "source": [
    "## Managing Concurrency"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38339871-7f3d-49d8-9b4f-e77f9e2a88da",
   "metadata": {},
   "source": [
    "### Creating and Managing Threads in Rust"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c03bfa03-ee78-4267-8d9b-582b98865f88",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::thread;\n",
    "\n",
    "let handle = thread::spawn(|| {\n",
    "    // Code for a new thread goes here.\n",
    "});\n",
    "\n",
    "handle.join().unwrap();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1076c94d-372d-48e5-ad61-2cde2587f1ee",
   "metadata": {},
   "source": [
    "### Sharing Data Between Threads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "21af2e95-fe3e-4c88-989d-4ba92ac5b22e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "use std::thread;\n",
    "\n",
    "let data = vec![1, 2, 3, 4, 5];\n",
    "\n",
    "let handle = thread::spawn(move || {\n",
    "    // Code for the new thread goes here.\n",
    "    println!(\"{:?}\", data);\n",
    "});\n",
    "\n",
    "handle.join().unwrap();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "523c632c-e041-4a81-b105-2b924b7c4b62",
   "metadata": {},
   "source": [
    "### Synchronization Primitives"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acc30d4f-55ee-4217-b44e-b27c58439c04",
   "metadata": {},
   "source": [
    "#### Basic Usage of Mutex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6a938a11-c989-4556-ace8-a13a6cbcdb42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data after modification: 43\n"
     ]
    }
   ],
   "source": [
    "use std::sync::Mutex;\n",
    "\n",
    "let data = Mutex::new(42);\n",
    "\n",
    "{\n",
    "    let mut guard = data.lock().unwrap();\n",
    "    *guard += 1;\n",
    "} // Guard goes out of scope, unlocking the Mutex\n",
    "\n",
    "println!(\"Data after modification: {:?}\", *data.lock().unwrap());"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ee276a9-c379-429a-a74d-4d836c693fc5",
   "metadata": {},
   "source": [
    "#### Sharing Data Across Threads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f1d581b0-8e46-4140-b6e7-474e7cb0cb73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Counter Value: 5\n"
     ]
    }
   ],
   "source": [
    "use std::sync::{Mutex, Arc};\n",
    "use std::thread;\n",
    "\n",
    "let data = Arc::new(Mutex::new(0));\n",
    "let mut handles = vec![];\n",
    "\n",
    "for _ in 0..5 {\n",
    "    let data = Arc::clone(&data);\n",
    "\n",
    "    let handle = thread::spawn(move || {\n",
    "        let mut guard = data.lock().unwrap();\n",
    "        *guard += 1;\n",
    "    });\n",
    "\n",
    "    handles.push(handle);\n",
    "}\n",
    "\n",
    "for handle in handles {\n",
    "    handle.join().unwrap();\n",
    "}\n",
    "\n",
    "println!(\"Final Counter Value: {:?}\", *data.lock().unwrap());"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c249b08-e7b8-4827-9952-c9b9a1048f66",
   "metadata": {},
   "source": [
    "#### Avoiding Mutex Deadlocks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f2603982-adb7-4a18-90a0-85c59c3abc3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final values: data1 = 3, data2 = 2\n"
     ]
    }
   ],
   "source": [
    "use std::sync::{Mutex, Arc};\n",
    "use std::thread;\n",
    "\n",
    "let data1 = Arc::new(Mutex::new(0));\n",
    "let data2 = Arc::new(Mutex::new(0));\n",
    "\n",
    "let data1_final = Arc::new(Mutex::new(0));\n",
    "let data2_final = Arc::new(Mutex::new(0));\n",
    "\n",
    "let handles = vec![\n",
    "    thread::spawn({\n",
    "        let data1_clone = Arc::clone(&data1);\n",
    "        let data2_clone = Arc::clone(&data2);\n",
    "        move || {\n",
    "            let mut guard1 = data1_clone.lock().unwrap();\n",
    "            *guard1 += 1;\n",
    "            let mut guard2 = data2_clone.lock().unwrap();\n",
    "            *guard2 += 1;\n",
    "            (1, 0)\n",
    "        }\n",
    "    }),\n",
    "    thread::spawn({\n",
    "        let data1_clone = Arc::clone(&data1);\n",
    "        move || {\n",
    "            let mut guard1 = data1_clone.lock().unwrap();\n",
    "            *guard1 += 1;\n",
    "            (0, 1)\n",
    "        }\n",
    "    }),\n",
    "];\n",
    "\n",
    "let results: Vec<(i32, i32)> = handles\n",
    "    .into_iter()\n",
    "    .map(|handle| handle.join().unwrap())\n",
    "    .collect();\n",
    "\n",
    "let final_value1: i32 = results.iter().map(|&(val1, _)| val1).sum();\n",
    "let final_value2: i32 = results.iter().map(|&(_, val2)| val2).sum();\n",
    "\n",
    "{\n",
    "    let mut guard1_final = data1_final.lock().unwrap();\n",
    "    let mut guard2_final = data2_final.lock().unwrap();\n",
    "    *guard1_final = *data1.lock().unwrap() + final_value1;\n",
    "    *guard2_final = *data2.lock().unwrap() + final_value2;\n",
    "}\n",
    "\n",
    "println!(\n",
    "    \"Final values: data1 = {}, data2 = {}\",\n",
    "    *data1_final.lock().unwrap(),\n",
    "    *data2_final.lock().unwrap()\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba4dbcec-92f0-4fbf-85a3-e74d0d66b424",
   "metadata": {},
   "source": [
    "#### Ownership of Mutex Guards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8b0ef968-657a-4362-bf8b-b5094306a085",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data: [1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "use std::sync::Mutex;\n",
    "\n",
    "let data = Mutex::new(vec![1, 2, 3]);\n",
    "\n",
    "{\n",
    "    let mut guard = data.lock().unwrap();\n",
    "    guard.push(4);\n",
    "} // Guard goes out of scope, unlocking the Mutex\n",
    "\n",
    "// Attempting to modify the data outside the guard's scope\n",
    "// let mut guard = data.lock().unwrap(); // This line would fail to compile\n",
    "\n",
    "println!(\"Data: {:?}\", *data.lock().unwrap());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e10388ad-ad77-4040-aafa-419add3443fa",
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "The variable `guard` contains a reference with a non-static lifetime so\ncan't be persisted. You can prevent this error by making sure that the\nvariable goes out of scope - i.e. wrapping the code in {}.",
     "output_type": "error",
     "traceback": [
      "\u001b[31mError:\u001b[0m The variable `guard` contains a reference with a non-static lifetime so",
      "can't be persisted. You can prevent this error by making sure that the",
      "variable goes out of scope - i.e. wrapping the code in {}."
     ]
    }
   ],
   "source": [
    "use std::sync::Mutex;\n",
    "\n",
    "let data = Mutex::new(vec![1, 2, 3]);\n",
    "\n",
    "{\n",
    "    let mut guard = data.lock().unwrap();\n",
    "    guard.push(4);\n",
    "} // Guard goes out of scope, unlocking the Mutex\n",
    "\n",
    "let mut guard = data.lock().unwrap(); // This line would fail to compile\n",
    "\n",
    "println!(\"Data: {:?}\", *data.lock().unwrap());"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2bc554b-f984-4947-ab26-99ac6f4d13b0",
   "metadata": {},
   "source": [
    "#### Handling Poisoned Mutexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fc65b806-eb79-4b59-8597-32952b7858bf",
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "unused variable: `data`",
     "output_type": "error",
     "traceback": [
      "\u001b[91munused variable: `data`\u001b[0m"
     ]
    }
   ],
   "source": [
    "use std::sync::{Mutex, Arc};\n",
    "use std::thread;\n",
    "\n",
    "let data = Arc::new(Mutex::new(0));\n",
    "let mut handles = vec![];\n",
    "\n",
    "for _ in 0..5 {\n",
    "    let data = Arc::clone(&data);\n",
    "\n",
    "    let handle = thread::spawn(move || {\n",
    "        let mut guard = data.lock().unwrap();\n",
    "        if *guard == 3 {\n",
    "            println!(\"Thread reached 3, stopping.\");\n",
    "            return; // Don't panic, just exit the thread.\n",
    "        }\n",
    "        *guard += 1;\n",
    "    });\n",
    "\n",
    "    handles.push(handle);\n",
    "}\n",
    "\n",
    "for handle in handles {\n",
    "    handle.join().unwrap();\n",
    "}\n",
    "\n",
    "let result = data.lock();\n",
    "match result {\n",
    "    Ok(guard) => println!(\"Final Counter Value: {:?}\", *guard),\n",
    "    Err(poisoned) => {\n",
    "        let guard = poisoned.into_inner();\n",
    "        println!(\"Mutex is poisoned. Recovered Counter Value: {:?}\", *guard);\n",
    "    }\n",
    "}\n",
    "\n",
    "// TODO: report this bug, it executes as expected if wrapped with the main as shown below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ea7177a5-fe51-4454-8872-9f5b1ce4de09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thread reached 3, stopping.\n",
      "Thread reached 3, stopping.\n",
      "Final Counter Value: 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::{Mutex, Arc};\n",
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    let data = Arc::new(Mutex::new(0));\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for _ in 0..5 {\n",
    "        let data = Arc::clone(&data);\n",
    "\n",
    "        let handle = thread::spawn(move || {\n",
    "            let mut guard = data.lock().unwrap();\n",
    "            if *guard == 3 {\n",
    "                println!(\"Thread reached 3, stopping.\");\n",
    "                return; // Don't panic, just exit the thread.\n",
    "            }\n",
    "            *guard += 1;\n",
    "        });\n",
    "\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "\n",
    "    let result = data.lock();\n",
    "    match result {\n",
    "        Ok(guard) => println!(\"Final Counter Value: {:?}\", *guard),\n",
    "        Err(poisoned) => {\n",
    "            let guard = poisoned.into_inner();\n",
    "            println!(\"Mutex is poisoned. Recovered Counter Value: {:?}\", *guard);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48c89816-170c-4217-8524-d4cd209a535e",
   "metadata": {},
   "source": [
    "### Advanced Usage of Mutex"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0b50546-0c83-41e2-991a-6fcc620bc931",
   "metadata": {},
   "source": [
    "#### Conditional Locking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "44c76084-a061-4cb2-8a25-caf34a77a7bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data: [1, 0, 2, 3, 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::{Arc, Condvar, Mutex};\n",
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    let data = Arc::new((Mutex::new(Vec::new()), Condvar::new()));\n",
    "\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for i in 0..5 {\n",
    "        let data_clone = Arc::clone(&data);\n",
    "\n",
    "        let handle = thread::spawn(move || {\n",
    "            let (lock, cvar) = &*data_clone;\n",
    "\n",
    "            let mut data = lock.lock().unwrap();\n",
    "\n",
    "            data.push(i);\n",
    "\n",
    "            cvar.notify_one();\n",
    "        });\n",
    "\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    let (lock, cvar) = &*data;\n",
    "    let mut data = lock.lock().unwrap();\n",
    "\n",
    "    while data.len() < 5 {\n",
    "        data = cvar.wait(data).unwrap();\n",
    "    }\n",
    "\n",
    "    println!(\"Data: {:?}\", *data);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7306b9b9-c15c-4e28-a411-b4be216910cf",
   "metadata": {},
   "source": [
    "#### Implementing a Mutex-Protected Queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "4ba6a1d5-e0ef-4806-92ee-036743f0dcc0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Queue: [0, 1, 2, 3, 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::{Arc, Mutex};\n",
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    let queue = Arc::new(Mutex::new(Vec::new()));\n",
    "\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for i in 0..5 {\n",
    "        let queue_clone = Arc::clone(&queue);\n",
    "\n",
    "        let handle = thread::spawn(move || {\n",
    "            let mut queue = queue_clone.lock().unwrap();\n",
    "\n",
    "            queue.push(i);\n",
    "        });\n",
    "\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "\n",
    "    let final_queue = queue.lock().unwrap();\n",
    "\n",
    "    println!(\"Final Queue: {:?}\", *final_queue);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1be15e8-2332-4c13-9ac3-a23c81d50c27",
   "metadata": {},
   "source": [
    "#### Implementing a Mutex-Protected Priority Queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "55bb5ed3-ef2b-42f3-8c56-057ed83f97e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Popped: 5\n",
      "Popped: 4\n",
      "Popped: 3\n",
      "Popped: 2\n",
      "Popped: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::BinaryHeap;\n",
    "use std::sync::{Arc, Mutex};\n",
    "use std::thread;\n",
    "\n",
    "struct PriorityQueue<T> {\n",
    "    inner: Mutex<BinaryHeap<T>>,\n",
    "}\n",
    "\n",
    "impl<T: Ord> PriorityQueue<T> {\n",
    "    fn new() -> Self {\n",
    "        PriorityQueue {\n",
    "            inner: Mutex::new(BinaryHeap::new()),\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fn push(&self, item: T) {\n",
    "        let mut heap = self.inner.lock().unwrap();\n",
    "        heap.push(item);\n",
    "    }\n",
    "\n",
    "    fn pop(&self) -> Option<T> {\n",
    "        let mut heap = self.inner.lock().unwrap();\n",
    "        heap.pop()\n",
    "    }\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let priority_queue = Arc::new(PriorityQueue::new());\n",
    "    let mut push_handles = vec![];\n",
    "    let mut pop_handles = vec![];\n",
    "\n",
    "    for i in (1..6).rev() {\n",
    "        let priority_queue_clone = Arc::clone(&priority_queue);\n",
    "        let handle = thread::spawn(move || {\n",
    "            priority_queue_clone.push(i);\n",
    "        });\n",
    "        push_handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in push_handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "\n",
    "    for _ in 0..5 {\n",
    "        let priority_queue_clone = Arc::clone(&priority_queue);\n",
    "        let handle = thread::spawn(move || {\n",
    "            let popped = priority_queue_clone.pop();\n",
    "            match popped {\n",
    "                Some(val) => println!(\"Popped: {}\", val),\n",
    "                None => println!(\"Queue is empty!\"),\n",
    "            }\n",
    "        });\n",
    "        pop_handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in pop_handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86980376-54c8-4346-a846-418bd11bb665",
   "metadata": {},
   "source": [
    "#### Handling Deadlocks with Mutex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a9f009a0-50fe-4f2a-a0ee-b40776d40aac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Data: 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::{Arc, Mutex};\n",
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    let lock = Arc::new(Mutex::new(0));\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for _ in 0..5 {\n",
    "        let lock_clone = Arc::clone(&lock);\n",
    "        let handle = thread::spawn(move || {\n",
    "            let mut data = lock_clone.try_lock();\n",
    "            match data {\n",
    "                Ok(ref mut value) => {\n",
    "                    **value += 1;\n",
    "                }\n",
    "                Err(_) => {\n",
    "                    println!(\"Failed to acquire lock, continuing...\");\n",
    "                }\n",
    "            }\n",
    "        });\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "\n",
    "    let final_data = lock.lock().unwrap();\n",
    "    println!(\"Final Data: {}\", *final_data);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "990062e2-a934-4776-b582-5c32845d718b",
   "metadata": {},
   "source": [
    "#### Mutex in Multi-Threaded Producer-Consumer Scenario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "457fb7f7-c557-4b61-99d6-4360eda707c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Consumed: 14\n",
      "Consumed: 13\n",
      "Consumed: 12\n",
      "Consumed: 11\n",
      "Consumed: 10\n",
      "Consumed: 9\n",
      "Consumed: 8\n",
      "Consumed: 7\n",
      "Consumed: 6\n",
      "Consumed: 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::{Arc, Mutex};\n",
    "use std::thread;\n",
    "\n",
    "const BUFFER_SIZE: usize = 5;\n",
    "\n",
    "fn main() {\n",
    "    let buffer = Arc::new(Mutex::new(Vec::new()));\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    // Producer threads\n",
    "    for i in 0..3 {\n",
    "        let buffer_clone = Arc::clone(&buffer);\n",
    "        let handle = thread::spawn(move || {\n",
    "            for j in 0..BUFFER_SIZE {\n",
    "                let mut buffer = buffer_clone.lock().unwrap();\n",
    "                buffer.push(i * BUFFER_SIZE + j);\n",
    "            }\n",
    "        });\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    // Consumer threads\n",
    "    for _ in 0..2 {\n",
    "        let buffer_clone = Arc::clone(&buffer);\n",
    "        let handle = thread::spawn(move || {\n",
    "            for _ in 0..BUFFER_SIZE {\n",
    "                let mut buffer = buffer_clone.lock().unwrap();\n",
    "                if let Some(item) = buffer.pop() {\n",
    "                    println!(\"Consumed: {}\", item);\n",
    "                }\n",
    "            }\n",
    "        });\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea77b6fb-cb20-4132-8248-df8c5a3e0e1a",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "### Exploring RwLock"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e96829f-f32e-4644-adad-03f3a41d020d",
   "metadata": {},
   "source": [
    "#### Managing Shared Data with RwLock"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e4172db5-6c0e-4790-8aba-00b90e54a0c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read: 0\n",
      "Read: 0\n",
      "Read: 0\n",
      "Read: 0\n",
      "Read: 0\n",
      "Result: 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::thread;\n",
    "use std::sync::{RwLock, Arc};\n",
    "\n",
    "fn main() {\n",
    "    let data = Arc::new(RwLock::new(0));\n",
    "\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for _ in 0..5 {\n",
    "        let data = Arc::clone(&data);\n",
    "\n",
    "        let handle = thread::spawn(move || {\n",
    "            let data_guard = data.read().unwrap();\n",
    "            println!(\"Read: {}\", *data_guard);\n",
    "\n",
    "            // Drop the read lock here to allow other threads to read concurrently\n",
    "            drop(data_guard);\n",
    "            thread::sleep(std::time::Duration::from_millis(100));\n",
    "\n",
    "            let mut data_write = data.write().unwrap();\n",
    "            *data_write += 1;\n",
    "        });\n",
    "\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "\n",
    "    println!(\"Result: {:?}\", *data.read().unwrap());\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90eaaae1-1b18-4c00-9ebf-425093bf9387",
   "metadata": {},
   "source": [
    "#### Advanced Usages of RwLock"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63480c9b-f61b-4928-bf1d-17fd9790464a",
   "metadata": {},
   "source": [
    "##### Dynamic Number of Readers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7d051921-9fff-4e37-b6bc-1761c2c303ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reader 0: 0\n",
      "Reader 1: 0\n",
      "Reader 2: 0\n",
      "Reader 4: 0\n",
      "Reader 3: 0\n",
      "Reader 5: 0\n",
      "Reader 6: 0\n",
      "Reader 7: 0\n",
      "Reader 8: 0\n",
      "Reader 9: 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::{RwLock, Arc};\n",
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    let data = Arc::new(RwLock::new(0));\n",
    "\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for i in 0..10 {\n",
    "        let data = Arc::clone(&data);\n",
    "\n",
    "        let handle = thread::spawn(move || {\n",
    "            let data_guard = data.read().unwrap();\n",
    "            println!(\"Reader {}: {}\", i, *data_guard);\n",
    "        });\n",
    "\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fdd3d56-b398-43f3-9a15-f33c4374e050",
   "metadata": {},
   "source": [
    "##### Timed Locking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "847c77d1-a146-493a-a05d-c1267ca82303",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::sync::{RwLock, Arc};\n",
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    let data1 = Arc::new(RwLock::new(0));\n",
    "    let data2 = Arc::new(RwLock::new(0));\n",
    "\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for _ in 0..5 {\n",
    "        let data1 = Arc::clone(&data1);\n",
    "        let data2 = Arc::clone(&data2);\n",
    "\n",
    "        let handle = thread::spawn(move || {\n",
    "            let mut data_guard1 = data1.write().unwrap();\n",
    "            let mut data_guard2 = data2.write().unwrap();\n",
    "\n",
    "            // Perform operations on both data1 and data2\n",
    "            *data_guard1 += 1;\n",
    "            *data_guard2 += 1;\n",
    "        });\n",
    "\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82af3a1b-a3d4-4878-b933-c144f3d5963a",
   "metadata": {},
   "source": [
    "##### Deadlock Avoidance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b11f5a0d-f6b6-4654-b8d1-a233ab2d2629",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::{RwLock, Arc};\n",
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    let data1 = Arc::new(RwLock::new(0));\n",
    "    let data2 = Arc::new(RwLock::new(0));\n",
    "\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for _ in 0..5 {\n",
    "        let data1 = Arc::clone(&data1);\n",
    "        let data2 = Arc::clone(&data2);\n",
    "\n",
    "        let handle = thread::spawn(move || {\n",
    "            let mut data_guard1 = data1.write().unwrap();\n",
    "            let mut data_guard2 = data2.write().unwrap();\n",
    "\n",
    "            // Perform operations on both data1 and data2\n",
    "            *data_guard1 += 1;\n",
    "            *data_guard2 += 1;\n",
    "        });\n",
    "\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb10bda8-4d7e-40fb-9793-8fa41dcc8946",
   "metadata": {},
   "source": [
    "##### Implementing Resource Pooling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "5ca90d9e-f9cb-4e93-85c1-dc2700a910dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thread 0 accessed Resource 0\n",
      "Thread 1 accessed Resource 1\n",
      "Thread 2 accessed Resource 2\n",
      "Thread 3 accessed Resource 0\n",
      "Thread 4 accessed Resource 1\n",
      "Thread 5 accessed Resource 2\n",
      "Thread 6 accessed Resource 0\n",
      "Thread 8 accessed Resource 2\n",
      "Thread 7 accessed Resource 1\n",
      "Thread 9 accessed Resource 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::{RwLock, Arc};\n",
    "use std::thread;\n",
    "\n",
    "struct Resource {\n",
    "    id: u32,\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    const NUM_RESOURCES: u32 = 3;\n",
    "    let resources: Vec<Arc<RwLock<Resource>>> = (0..NUM_RESOURCES)\n",
    "        .map(|id| Arc::new(RwLock::new(Resource { id })))\n",
    "        .collect();\n",
    "\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for i in 0..10 {\n",
    "        let resources_clone: Vec<Arc<RwLock<Resource>>> = resources.clone();\n",
    "\n",
    "        let handle = thread::spawn(move || {\n",
    "            let idx = (i % NUM_RESOURCES) as usize;\n",
    "            let resource = &resources_clone[idx];\n",
    "            let data_guard = resource.read().unwrap();\n",
    "            println!(\"Thread {} accessed Resource {}\", i, data_guard.id);\n",
    "        });\n",
    "\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0b03231-6548-4cd8-af2e-a0a8592f0dd9",
   "metadata": {},
   "source": [
    "### Techniques for Thread Communication and Message Passing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b4568bc-617a-49f4-896a-e8f6ac2cba0d",
   "metadata": {},
   "source": [
    "#### Using Channels for Communication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "35327ffa-8615-4ac3-9aae-a600c4199dd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Received: Hello from the sender thread\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::thread;\n",
    "use std::sync::mpsc;\n",
    "\n",
    "fn main() {\n",
    "    let (sender, receiver) = mpsc::channel();\n",
    "\n",
    "    let sender_clone = sender.clone();\n",
    "    let handle = thread::spawn(move || {\n",
    "        let message = \"Hello from the sender thread\".to_string();\n",
    "        sender_clone.send(message).unwrap();\n",
    "    });\n",
    "\n",
    "    let received_data = receiver.recv().unwrap();\n",
    "    println!(\"Received: {}\", received_data);\n",
    "\n",
    "    handle.join().unwrap();\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7702eebb-661a-4506-980b-af8f7c9c3cab",
   "metadata": {},
   "source": [
    "#### Message Passing with Structs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "94b26518-3d6c-4894-bc20-0d27a9ee80e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Received Message - ID: 42, Content: Important data\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::thread;\n",
    "use std::sync::mpsc;\n",
    "\n",
    "struct CustomMessage {\n",
    "    id: u32,\n",
    "    content: String,\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let (sender, receiver) = mpsc::channel();\n",
    "\n",
    "    let sender_clone = sender.clone();\n",
    "    let handle = thread::spawn(move || {\n",
    "        let message = CustomMessage {\n",
    "            id: 42,\n",
    "            content: \"Important data\".to_string(),\n",
    "        };\n",
    "        sender_clone.send(message).unwrap();\n",
    "    });\n",
    "\n",
    "    let received_message = receiver.recv().unwrap();\n",
    "    println!(\"Received Message - ID: {}, Content: {}\", received_message.id, received_message.content);\n",
    "\n",
    "    handle.join().unwrap();\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3535c93-0c83-49ed-be45-0e6b8e42cf4e",
   "metadata": {},
   "source": [
    "#### Atomic Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "fd8bc541-e8e0-4558-aefd-0e76951bb14a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Counter Value: 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::atomic::{AtomicUsize, Ordering};\n",
    "\n",
    "fn main() {\n",
    "    let counter = Arc::new(AtomicUsize::new(0));\n",
    "\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for _ in 0..5 {\n",
    "        let counter = Arc::clone(&counter);\n",
    "\n",
    "        let handle = thread::spawn(move || {\n",
    "            counter.fetch_add(1, Ordering::Relaxed);\n",
    "        });\n",
    "\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "\n",
    "    let final_value = counter.load(Ordering::Relaxed);\n",
    "    println!(\"Final Counter Value: {}\", final_value);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25bc57f4-b032-47b2-9552-a7a371033a42",
   "metadata": {},
   "source": [
    "### Advanced Thread Communication"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6a278ba-c2e5-4273-b41f-f685c1a8007c",
   "metadata": {},
   "source": [
    "#### Thread Coordination with Barriers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "b047fd33-aaa0-4385-910c-fdfa3be1dc6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thread 0 started\n",
      "Thread 1 started\n",
      "Thread 2 started\n",
      "Thread 0 completed its work\n",
      "Thread 2 completed its work\n",
      "Thread 1 completed its work\n",
      "Thread 1 reached the barrier\n",
      "Thread 2 reached the barrier\n",
      "Thread 0 reached the barrier\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::{Arc, Barrier};\n",
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    let barrier = Arc::new(Barrier::new(3));\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for id in 0..3 {\n",
    "        let barrier = Arc::clone(&barrier);\n",
    "        let handle = thread::spawn(move || {\n",
    "            println!(\"Thread {} started\", id);\n",
    "            thread::sleep(std::time::Duration::from_secs(2));\n",
    "            println!(\"Thread {} completed its work\", id);\n",
    "            barrier.wait(); // <7>\n",
    "            println!(\"Thread {} reached the barrier\", id);\n",
    "        });\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc7567a9-1982-47ae-b85e-d1c254eec691",
   "metadata": {},
   "source": [
    "#### Thread Local Storage (TLS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "6dce2b1b-6c6a-43a6-a089-db0eb6a4939a",
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "cannot find value `THREAD_LOCAL_DATA` in this scope",
     "output_type": "error",
     "traceback": [
      "\u001b[31m[E0425] Error:\u001b[0m cannot find value `THREAD_LOCAL_DATA` in this scope",
      "    \u001b[38;5;246m╭\u001b[0m\u001b[38;5;246m─\u001b[0m\u001b[38;5;246m[\u001b[0mcommand_43:1:1\u001b[38;5;246m]\u001b[0m",
      "    \u001b[38;5;246m│\u001b[0m",
      " \u001b[38;5;246m12 │\u001b[0m \u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;54mT\u001b[0m\u001b[38;5;54mH\u001b[0m\u001b[38;5;54mR\u001b[0m\u001b[38;5;54mE\u001b[0m\u001b[38;5;54mA\u001b[0m\u001b[38;5;54mD\u001b[0m\u001b[38;5;54m_\u001b[0m\u001b[38;5;54mL\u001b[0m\u001b[38;5;54mO\u001b[0m\u001b[38;5;54mC\u001b[0m\u001b[38;5;54mA\u001b[0m\u001b[38;5;54mL\u001b[0m\u001b[38;5;54m_\u001b[0m\u001b[38;5;54mD\u001b[0m\u001b[38;5;54mA\u001b[0m\u001b[38;5;54mT\u001b[0m\u001b[38;5;54mA\u001b[0m\u001b[38;5;249m.\u001b[0m\u001b[38;5;249mw\u001b[0m\u001b[38;5;249mi\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249mh\u001b[0m\u001b[38;5;249m(\u001b[0m\u001b[38;5;249m|\u001b[0m\u001b[38;5;249md\u001b[0m\u001b[38;5;249ma\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249ma\u001b[0m\u001b[38;5;249m|\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m{\u001b[0m",
      " \u001b[38;5;240m   │\u001b[0m             \u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m┬\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m  ",
      " \u001b[38;5;240m   │\u001b[0m                     \u001b[38;5;54m╰\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m not found in this scope",
      "\u001b[38;5;246m────╯\u001b[0m"
     ]
    },
    {
     "ename": "Error",
     "evalue": "cannot find value `THREAD_LOCAL_DATA` in this scope",
     "output_type": "error",
     "traceback": [
      "\u001b[31m[E0425] Error:\u001b[0m cannot find value `THREAD_LOCAL_DATA` in this scope",
      "    \u001b[38;5;246m╭\u001b[0m\u001b[38;5;246m─\u001b[0m\u001b[38;5;246m[\u001b[0mcommand_43:1:1\u001b[38;5;246m]\u001b[0m",
      "    \u001b[38;5;246m│\u001b[0m",
      " \u001b[38;5;246m25 │\u001b[0m \u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;54mT\u001b[0m\u001b[38;5;54mH\u001b[0m\u001b[38;5;54mR\u001b[0m\u001b[38;5;54mE\u001b[0m\u001b[38;5;54mA\u001b[0m\u001b[38;5;54mD\u001b[0m\u001b[38;5;54m_\u001b[0m\u001b[38;5;54mL\u001b[0m\u001b[38;5;54mO\u001b[0m\u001b[38;5;54mC\u001b[0m\u001b[38;5;54mA\u001b[0m\u001b[38;5;54mL\u001b[0m\u001b[38;5;54m_\u001b[0m\u001b[38;5;54mD\u001b[0m\u001b[38;5;54mA\u001b[0m\u001b[38;5;54mT\u001b[0m\u001b[38;5;54mA\u001b[0m\u001b[38;5;249m.\u001b[0m\u001b[38;5;249mw\u001b[0m\u001b[38;5;249mi\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249mh\u001b[0m\u001b[38;5;249m(\u001b[0m\u001b[38;5;249m|\u001b[0m\u001b[38;5;249md\u001b[0m\u001b[38;5;249ma\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249ma\u001b[0m\u001b[38;5;249m|\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m{\u001b[0m",
      " \u001b[38;5;240m   │\u001b[0m     \u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m┬\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m  ",
      " \u001b[38;5;240m   │\u001b[0m             \u001b[38;5;54m╰\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m not found in this scope",
      "\u001b[38;5;246m────╯\u001b[0m"
     ]
    }
   ],
   "source": [
    "use std::thread;\n",
    "use std::thread_local;\n",
    "\n",
    "thread_local! {\n",
    "    static THREAD_LOCAL_DATA: std::cell::RefCell<u32> = std::cell::RefCell::new(42);\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let mut handles = vec![];\n",
    "    for _ in 0..5 {\n",
    "        let handle = thread::spawn(|| {\n",
    "            THREAD_LOCAL_DATA.with(|data| {\n",
    "                let mut value = data.borrow_mut();\n",
    "                *value += 1;\n",
    "                println!(\"Thread-local value: {}\", *value);\n",
    "            });\n",
    "        });\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "\n",
    "    THREAD_LOCAL_DATA.with(|data| {\n",
    "        let value = data.borrow();\n",
    "        println!(\"Main thread's thread-local value: {}\", *value);\n",
    "    });\n",
    "}\n",
    "\n",
    "main()\n",
    "\n",
    "// TODO: file a bug for `thread_local` macro not working"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1335e001-d368-4083-aa41-8a2fb6f9ba98",
   "metadata": {},
   "source": [
    "#### Crossbeam Library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "f3905883-8576-414d-a33f-5e47255bd426",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep crossbeam = {version = \"0.8\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "0d55862f-0c6f-4ad3-ae40-d05a881b583f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scoped thread 0\n",
      "Scoped thread 1\n",
      "Scoped thread 2\n",
      "Scoped thread 3\n",
      "Scoped thread 4\n"
     ]
    }
   ],
   "source": [
    "use crossbeam::thread;\n",
    "\n",
    "thread::scope(|s| {\n",
    "    for i in 0..5 {\n",
    "        s.spawn(move |_| {\n",
    "            println!(\"Scoped thread {}\", i);\n",
    "        });\n",
    "    }\n",
    "}).unwrap();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45ddb05b-f78a-4035-b499-649455b00ff9",
   "metadata": {},
   "source": [
    "### Asynchronous Programming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "edf38b35-d84e-4905-8dc5-c0708a99b008",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep async-std = {version = \"1.12.0\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "31f412f4-7821-44d4-b30f-e26041d88f9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task 1: Starting\n",
      "Task 2: Starting\n",
      "Task 2: Finished\n",
      "Task 1: Finished\n",
      "All tasks have completed\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use async_std::task;\n",
    "\n",
    "fn main() {\n",
    "    task::block_on(async {\n",
    "        let task1 = task::spawn(async {\n",
    "            println!(\"Task 1: Starting\");\n",
    "            // Simulate an asynchronous task with a delay.\n",
    "            async_std::task::sleep(std::time::Duration::from_secs(2)).await;\n",
    "            println!(\"Task 1: Finished\");\n",
    "        });\n",
    "\n",
    "        let task2 = task::spawn(async {\n",
    "            println!(\"Task 2: Starting\");\n",
    "            // Simulate another asynchronous task with a delay.\n",
    "            async_std::task::sleep(std::time::Duration::from_secs(1)).await;\n",
    "            println!(\"Task 2: Finished\");\n",
    "        });\n",
    "\n",
    "        task1.await;\n",
    "        task2.await;\n",
    "\n",
    "        println!(\"All tasks have completed\");\n",
    "    });\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d6c1b49-a109-4a19-b529-b4915509a913",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}