代码片段仓库

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

std::mutex mutex;
std::vector<int> shared_data;

void thread_func() {
    std::lock_guard<std::mutex> lock(mutex);
    // Access shared data
    shared_data.push_back(std::rand() % 100);
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; i++) {
        threads.push_back(std::thread(thread_func));
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    for (int val : shared_data) {
        std::cout << val << " ";
    }
    return 0;
}

const data = [1, 2, 3, 4, 5];

// Map to squares
const squares = data.map(x => x * x);

// Filter even numbers
const evens = data.filter(x => x % 2 === 0);

// Reduce to sum
const sum = data.reduce((acc, cur) => acc + cur, 0);

// Flatten nested arrays
const nested = [[1, 2], [3, 4], [5]];
const flat = nested.reduce((acc, arr) => acc.concat(arr), []);

console.log({quares, evens, sum, flat});

<?php

class DatabaseConnection {
    public function __construct(private $server, $port, $dbname) {}
    public function query($sql) {}
}

class UserRepository {
    private $db;
    
    public function __construct(DatabaseConnection $db) {
        $this->db = $db;
    }
    
    public function find($id) {
        $sql = "SELECT * FROM users WHERE id = $id";
        return $this->db->query($sql);
    }
}

// Usage
$db = new DatabaseConnection('localhost', 3306, 'mydb');
$repo = new UserRepository($db);
$user = $repo->find(123);

import asyncio
import time

async def fetch_data(delay, id):
    print(f"Starting task '{id}'")
    await asyncio.sleep(delay)
    print(f"Finished task '{id}'")
    return delay

async def main():
    task_1 = asyncio.create_task(fetch_data(2, 1))
    task_2 = asyncio.create_task(fetch_data(3, 2))
    
    await asyncio.gather(task_1, task_2)
    print("All tasks complete")

if __name__ == '__main__':
    asyncio.run(main())

import java.util.concurrent.*;

public class AsyncDemo {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(1000);
                System.out.println("Async task completed");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return null;
        });
        
        future.thenAccept(
            result -> System.out.println("Callback executed")
        );
        
        System.out.println("Main thread continues");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {}
    }
}

from dataclasses import dataclass

dataclass
class Point:
    x: float
    y: float
   
    def distance(self, other: 'Point') -> float:
        return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5

p1 = Point(1.0, 2.0)
p2 = Point(3.0, 4.0)
dist = p1.distance(p2)
print(f"Distance: {dist}")