Java与Rust的对比及快速上手技巧

fn main() {
    let mut s = String::from("hello");
    
    let r1 = &s; // 不可变借用
    let r2 = &s; // 另一个不可变借用，允许
    // let r3 = &mut s; // 错误！不能同时存在可变和不可变借用
    
    println!("{} and {}", r1, r2);
    
    let r3 = &mut s; // 现在可以可变借用，因为 r1 和 r2 不再使用
    r3.push_str(", world");
}

// 使用 ReentrantLock 实现细粒度锁控制
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区代码
} finally {
    lock.unlock();
}

// 使用 ConcurrentHashMap 实现线程安全的哈希表
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);

use std::sync::mpsc;
use std::thread;

let (tx, rx) = mpsc::channel();

thread::spawn(move || {
    let val = String::from("hello");
    tx.send(val).unwrap();
});

let received = rx.recv().unwrap();
println!("Got: {}", received);

use std::sync::{Mutex, Arc};
use std::thread;

let counter = Arc::new(Mutex::new(0));
letmut handles = vec![];

for _ in0..10 {
    let counter = Arc::clone(&counter);
    let handle = thread::spawn(move || {
        letmut num = counter.lock().unwrap();
        *num += 1;
    });
    handles.push(handle);
}

for handle in handles {
    handle.join().unwrap();
}

println!("Result: {}", *counter.lock().unwrap());

// 强引用示例
Object obj = new Object();  // 强引用
obj = null;  // 取消强引用，对象变为可回收状态

import java.lang.ref.*;

// 软引用 - 在内存不足时会被回收
SoftReference<byte[]> softRef = new SoftReference<>(new byte[1024 * 1024]);

// 弱引用 - 每次垃圾回收时都会被回收
WeakReference<Object> weakRef = new WeakReference<>(new Object());

// 虚引用 - 主要用于跟踪对象被回收的状态
ReferenceQueue<Object> queue = new ReferenceQueue<>();
PhantomReference<Object> phantomRef = new PhantomReference<>(new Object(), queue);

public class MemoryAllocation {
    // 实例变量 - 在堆中分配
    privateint instanceVar = 10;
    
    public void demonstrateAllocation() {
        // 局部变量 - 在栈帧中分配
        int localVar = 20;
        
        // 对象 - 在堆中分配，引用在栈中
        String str = new String("Hello, Heap!");
        
        // 数组 - 在堆中分配
        int[] array = newint[100];
    }
}

public class GCDemonstration {
    public static void main(String[] args) {
        // 创建对象引用链
        Node node1 = new Node("Node1");
        Node node2 = new Node("Node2");
        Node node3 = new Node("Node3");
        
        node1.next = node2;
        node2.next = node3;
        
        // 切断引用链，使部分对象不可达
        node2 = null;
        node3 = null;
        
        // 此时只有 node1 -> node2 (已null) -> node3 (已null)
        // node2 和 node3 成为垃圾回收候选对象
    }
    
    staticclass Node {
        String name;
        Node next;
        
        Node(String name) {
            this.name = name;
        }
        
        @Override
        protected void finalize() throws Throwable {
            System.out.println("Finalizing: " + name);
            super.finalize();
        }
    }
}

fn ownership_basics() {
    // 原则1：每个值都有一个所有者
    let s1 = String::from("hello");
    
    // 原则2：值在同一时间只能有一个所有者
    let s2 = s1; // s1 的所有权移动到 s2
    // println!("{}", s1); // 错误！s1 不再有效
    
    // 原则3：当所有者离开作用域，值被丢弃
    {
        let s3 = String::from("scope");
        // s3 在这里有效
    } // s3 离开作用域，内存被自动释放
    // println!("{}", s3); // 错误！s3 已离开作用域
}

fn stack_vs_heap() {
    // 栈分配 - 固定大小类型
    let x = 5;           // i32，在栈上分配
    let y = x;           // 值拷贝，两个独立变量
    
    // 堆分配 - 动态大小类型需要使用智能指针
    let s1 = String::from("hello");  // 字符串数据在堆上
    let s2 = s1;                     // 所有权转移，不是浅拷贝
    
    // 显式堆分配使用 Box<T>
    let boxed_int = Box::new(10);    // 整数在堆上分配
    let unboxed_int = *boxed_int;    // 解引用获取值
}

fn borrowing_rules() {
    let mut s = String::from("hello");
    
    // 不可变借用 - 可以有多个
    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);
    // r1 和 r2 的作用域在此结束
    
    // 可变借用 - 只能有一个，且不能与不可变借用共存
    let r3 = &mut s;
    r3.push_str(", world");
    // println!("{}", r1); // 错误！存在可变借用时不能使用不可变借用
}

// 生命周期注解 'a 表示两个参数和返回值具有相同的生命周期
fn longest<'a>(x: &'astr, y: &'astr) -> &'astr {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn lifetime_demonstration() {
    let string1 = String::from("long string is long");
    
    {
        let string2 = String::from("xyz");
        let result = longest(string1.as_str(), string2.as_str());
        println!("The longest string is {}", result);
    } // string2 离开作用域，result 也不再有效
}

public class JavaAllocation {
    // 类成员自动在堆中分配
    private Object member = new Object();
    
    public void allocate() {
        // 局部对象引用在栈中，对象在堆中
        Object local = new Object();
        
        // 数组在堆中分配
        int[] array = newint[1000];
        
        // 基本类型在栈中分配
        int primitive = 42;
    }
}

struct RustAllocation {
    // 结构体字段默认在栈上，但可以包含堆数据
    data: String,  // String 在堆上分配数据
}

impl RustAllocation {
    fn allocate() {
        // 基本类型在栈上
        let primitive: i32 = 42;
        
        // 需要时显式进行堆分配
        let boxed = Box::new(100);
        let string_data = String::from("heap allocated");
        
        // 数组在栈上（固定大小）或堆上（动态大小）
        let stack_array: [i32; 4] = [1, 2, 3, 4];
        let heap_vector: Vec<i32> = vec![1, 2, 3, 4];
    }
}

public class JavaReferenceSafety {
    public void demonstrateSafety() {
        List<String> list = new ArrayList<>();
        list.add("item1");
        
        // 多线程环境下的引用安全问题
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                // 可能产生并发修改异常
                if (!list.isEmpty()) {
                    String item = list.get(0); // 可能在其他线程中被修改
                    System.out.println(item);
                }
            }).start();
        }
    }
    
    // 使用同步机制保证安全
    public void safeConcurrentAccess() {
        List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
        synchronizedList.add("safe item");
        
        synchronized(synchronizedList) {
            for (String item : synchronizedList) {
                System.out.println(item);
            }
        }
    }
}

use std::sync::{Arc, Mutex};
use std::thread;

fn rust_reference_safety() {
    // 单线程环境下的借用检查
    letmut data = vec![1, 2, 3];
    
    // 不可变借用
    let read1 = &data;
    let read2 = &data;
    println!("{:?}, {:?}", read1, read2);
    
    // 可变借用 - 在不可变借用作用域结束后才允许
    let write = &mut data;
    write.push(4);
    
    // 多线程环境下的所有权转移
    let arc_data = Arc::new(Mutex::new(vec![1, 2, 3]));
    letmut handles = vec![];
    
    for i in0..3 {
        let data_clone = Arc::clone(&arc_data);
        let handle = thread::spawn(move || {
            letmut data = data_clone.lock().unwrap();
            data.push(i);
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
}

public class JavaMemoryReclamation {
    privatebyte[] largeObject = newbyte[1024 * 1024]; // 1MB
    
    // 对象变为不可达时成为GC候选
    public void createGarbage() {
        for (int i = 0; i < 1000; i++) {
            byte[] temp = newbyte[1024]; // 每次循环创建1KB垃圾
            // 循环结束后temp不可达，可被GC回收
        }
    }
    
    // 显式提示GC（但不保证立即执行）
    public void suggestGC() {
        System.gc(); // 只是建议，不保证立即执行
    }
    
    // 使用try-with-resources管理资源
    public void managedResources() throws IOException {
        try (FileInputStream fis = new FileInputStream("file.txt");
             BufferedReader reader = new BufferedReader(new InputStreamReader(fis))) {
            // 资源自动关闭
            String line = reader.readLine();
        } // 自动调用close()方法
    }
}

struct Resource {
    name: String,
}

impl Resource {
    fn new(name: &str) -> Resource {
        println!("创建资源: {}", name);
        Resource { name: name.to_string() }
    }
}

// Drop trait 实现确定性析构
implDropfor Resource {
    fn drop(&mutself) {
        println!("释放资源: {}", self.name);
    }
}

fn rust_deterministic_cleanup() {
    {
        let resource1 = Resource::new("资源1");
        let resource2 = Resource::new("资源2");
        println!("在作用域内使用资源");
    } // resource2 和 resource1 依次被drop
    
    println!("作用域结束，资源已释放");
    
    // 手动提前释放
    let early_release = Resource::new("提前释放");
    drop(early_release); // 显式调用drop
    println!("资源已手动释放");
}

public class JavaReferencePatterns {
    // 使用弱引用实现缓存
    publicstaticclass WeakReferenceCache<K, V> {
        privatefinal Map<K, WeakReference<V>> cache = new HashMap<>();
        
        public void put(K key, V value) {
            cache.put(key, new WeakReference<>(value));
        }
        
        public V get(K key) {
            WeakReference<V> ref = cache.get(key);
            return ref != null ? ref.get() : null;
        }
    }
    
    // 使用软引用实现内存敏感缓存
    publicstaticclass SoftReferenceCache<K, V> {
        privatefinal Map<K, SoftReference<V>> cache = new HashMap<>();
        
        public V getOrCreate(K key, Supplier<V> creator) {
            SoftReference<V> ref = cache.get(key);
            V value = ref != null ? ref.get() : null;
            
            if (value == null) {
                value = creator.get();
                cache.put(key, new SoftReference<>(value));
            }
            
            return value;
        }
    }
    
    // 防止内存泄漏的模式
    publicstaticclass SafeListenerPattern {
        privatefinal List<WeakReference<EventListener>> listeners = new ArrayList<>();
        
        public void addListener(EventListener listener) {
            // 使用弱引用避免监听器阻止GC
            listeners.add(new WeakReference<>(listener));
        }
        
        public void notifyListeners() {
            Iterator<WeakReference<EventListener>> iterator = listeners.iterator();
            while (iterator.hasNext()) {
                WeakReference<EventListener> ref = iterator.next();
                EventListener listener = ref.get();
                if (listener != null) {
                    listener.onEvent();
                } else {
                    iterator.remove(); // 清理已被GC的监听器
                }
            }
        }
    }
}

// 智能指针组合模式
use std::rc::Rc;
use std::cell::RefCell;

struct TreeNode<T> {
    value: T,
    children: Vec<Rc<RefCell<TreeNode<T>>>>,
    parent: Option<Weak<RefCell<TreeNode<T>>>>,
}

impl<T> TreeNode<T> {
    fn new(value: T) -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(TreeNode {
            value,
            children: Vec::new(),
            parent: None,
        }))
    }
    
    fn add_child(parent: &Rc<RefCell<TreeNode<T>>>, child: &Rc<RefCell<TreeNode<T>>>) {
        parent.borrow_mut().children.push(Rc::clone(child));
        child.borrow_mut().parent = Some(Rc::downgrade(parent));
    }
}

// 生命周期高级模式
struct StringSplitter<'a, 'b> {
    data: &'astr,
    delimiter: &'bstr,
    position: usize,
}

impl<'a, 'b> StringSplitter<'a, 'b> {
    fn new(data: &'astr, delimiter: &'bstr) -> Self {
        StringSplitter {
            data,
            delimiter,
            position: 0,
        }
    }
}

impl<'a, 'b> Iteratorfor StringSplitter<'a, 'b> {
    type Item = &'astr;
    
    fn next(&mutself) -> Option<Self::Item> {
        ifself.position >= self.data.len() {
            returnNone;
        }
        
        ifletSome(next_delim) = self.data[self.position..].find(self.delimiter) {
            let start = self.position;
            let end = self.position + next_delim;
            self.position = end + self.delimiter.len();
            Some(&self.data[start..end])
        } else {
            let result = &self.data[self.position..];
            self.position = self.data.len();
            Some(result)
        }
    }
}

// 异步编程中的所有权模式
use tokio::sync::mpsc;

asyncfn async_ownership_pattern() {
    let (tx, mut rx) = mpsc::channel(32);
    
    // 生产者任务 - 移动所有权到异步任务中
    let producer = tokio::spawn(asyncmove {
        for i in0..10 {
            tx.send(i).await.unwrap();
        }
    });
    
    // 消费者任务
    let consumer = tokio::spawn(asyncmove {
        whileletSome(message) = rx.recv().await {
            println!("收到: {}", message);
        }
    });
    
    let _ = tokio::join!(producer, consumer);
}

public class JavaReferencePerformance {
    privatestaticfinalint ITERATIONS = 1_000_000;
    
    // 强引用性能测试
    public void strongReferencePerformance() {
        long start = System.currentTimeMillis();
        
        List<Object> list = new ArrayList<>();
        for (int i = 0; i < ITERATIONS; i++) {
            Object obj = new Object();
            list.add(obj); // 强引用阻止GC
        }
        
        long duration = System.currentTimeMillis() - start;
        System.out.println("强引用耗时: " + duration + "ms");
    }
    
    // 弱引用性能测试
    public void weakReferencePerformance() {
        long start = System.currentTimeMillis();
        
        List<WeakReference<Object>> list = new ArrayList<>();
        for (int i = 0; i < ITERATIONS; i++) {
            Object obj = new Object();
            list.add(new WeakReference<>(obj)); // 允许GC回收
        }
        
        // 强制GC来观察效果
        System.gc();
        
        long duration = System.currentTimeMillis() - start;
        System.out.println("弱引用耗时: " + duration + "ms");
    }
}

use std::time::Instant;

fn ownership_performance() {
    const ITERATIONS: usize = 1_000_000;

    // 栈上分配：完全零开销
    let start = Instant::now();
    for _ in0..ITERATIONS {
        let x: u64 = 42;          // 只在寄存器/栈上
        std::hint::black_box(x);  // 防止编译器优化掉
    }
    let duration = start.elapsed();
    println!("栈分配耗时: {:?} (零堆分配)", duration);

    // 堆上分配但立即move，编译器可消除分配
    let start = Instant::now();
    for _ in0..ITERATIONS {
        let v = vec![1_u32, 2, 3]; // 只在循环内使用
        std::hint::black_box(v); // 所有权转移，编译器证明无别名后可栈上化
    }
    let duration = start.elapsed();
    println!("move语义+编译器优化后耗时: {:?}", duration);

    // 对比：强制堆分配且共享引用（Arc<Mutex>），模拟Java强引用
    use std::sync::{Arc, Mutex};
    let start = Instant::now();
    for _ in0..ITERATIONS {
        let data = Arc::new(Mutex::new(vec![1_u32, 2, 3]));
        std::hint::black_box(data);
    }
    let duration = start.elapsed();
    println!("Arc<Mutex>共享引用耗时: {:?}", duration);
}

public class SynchronizedAnalysis {
    privatefinal Object lock = new Object();
    privateint counter = 0;
    
    // 实例方法同步 - 锁对象为当前实例
    public synchronized void instanceMethod() {
        counter++;
        // 临界区代码
    }
    
    // 静态方法同步 - 锁对象为Class对象
    public static synchronized void staticMethod() {
        // 临界区代码
    }
    
    // 同步代码块 - 显式指定锁对象
    public void synchronizedBlock() {
        synchronized(lock) {
            counter++;
            // 更细粒度的锁控制
        }
    }
}

import java.util.concurrent.atomic.*;

publicclass AtomicOperations {
    privatefinal AtomicInteger atomicCounter = new AtomicInteger(0);
    privatefinal AtomicReference<String> atomicReference = new AtomicReference<>("initial");
    privatefinal LongAdder longAdder = new LongAdder(); // 高并发计数优化
    
    public void performAtomicOperations() {
        // CAS操作
        atomicCounter.compareAndSet(0, 1);
        
        // 原子更新
        atomicReference.updateAndGet(current -> current + "-updated");
        
        // 分段计数减少竞争
        longAdder.increment();
    }
}

import java.util.concurrent.*;

publicclass ConcurrentCollectionsDemo {
    privatefinal ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
    privatefinal CopyOnWriteArrayList<String> copyOnWriteList = new CopyOnWriteArrayList<>();
    privatefinal ConcurrentLinkedQueue<String> concurrentQueue = new ConcurrentLinkedQueue<>();
    
    public void demonstrateCollections() {
        // 分段锁实现的并发Map
        concurrentMap.compute("key", (k, v) -> v == null ? 1 : v + 1);
        
        // 写时复制列表，适合读多写少场景
        copyOnWriteList.add("element");
        
        // 无锁队列
        concurrentQueue.offer("item");
    }
}

public class ThreadPoolArchitecture {
    public void demonstrateThreadPools() {
        // 固定大小线程池
        ExecutorService fixedPool = Executors.newFixedThreadPool(10);
        
        // 缓存线程池
        ExecutorService cachedPool = Executors.newCachedThreadPool();
        
        // 定时任务线程池
        ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(5);
        
        // 自定义线程池
        ThreadPoolExecutor customPool = new ThreadPoolExecutor(
            5,  // 核心线程数
            20, // 最大线程数
            60, // 空闲时间
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1000), // 工作队列
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );
    }
}

public class VirtualThreadDemo {
    public void demonstrateVirtualThreads() throws Exception {
        // 创建虚拟线程
        Thread virtualThread = Thread.ofVirtual()
            .name("virtual-thread-", 0)
            .start(() -> {
                System.out.println("Running in virtual thread: " + Thread.currentThread());
            });
        
        // 使用ExecutorService管理虚拟线程
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futures = new ArrayList<>();
            
            for (int i = 0; i < 10_000; i++) {
                futures.add(executor.submit(() -> {
                    Thread.sleep(Duration.ofMillis(100));
                    return"Task completed: " + Thread.currentThread();
                }));
            }
            
            // 等待所有任务完成
            for (Future<String> future : futures) {
                System.out.println(future.get());
            }
        }
    }
}

use std::sync::{Arc, Mutex};
use std::thread;

pubfn ownership_concurrency() {
    // 使用Arc实现多线程共享所有权
    let data = Arc::new(Mutex::new(0));
    letmut handles = vec![];

    for _ in0..10 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            letmut num = data.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("最终结果: {}", *data.lock().unwrap());
}

// 自动实现Send的类型可以在线程间转移所有权
pubfn demonstrate_send() {
    let value = String::from("hello");
    
    // String实现了Send，可以移动到新线程
    let handle = thread::spawn(move || {
        println!("{}", value);
    });
    
    handle.join().unwrap();
}

// 自动实现Sync的类型可以安全地在多个线程间共享引用
pubfn demonstrate_sync() {
    let data = Arc::new(42);
    
    let handles: Vec<_> = (0..5).map(|_| {
        let data = Arc::clone(&data);
        thread::spawn(move || {
            println!("数据: {}", *data);
        })
    }).collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
}

use std::sync::{Mutex, RwLock};
use std::collections::HashMap;

pubfn mutex_patterns() {
    // Mutex保护可变数据
    let counter = Mutex::new(0);
    
    {
        letmut num = counter.lock().unwrap();
        *num += 1;
    } // 锁在这里自动释放
    
    // RwLock支持多读单写
    let cache = RwLock::new(HashMap::new());
    
    // 多个读取者可以同时访问
    let read_handles: Vec<_> = (0..3).map(|_| {
        let cache = cache.clone();
        thread::spawn(move || {
            ifletOk(guard) = cache.read() {
                println!("缓存大小: {}", guard.len());
            }
        })
    }).collect();
    
    // 单个写入者
    let write_handle = thread::spawn(move || {
        ifletOk(mut guard) = cache.write() {
            guard.insert("key".to_string(), "value".to_string());
        }
    });
    
    for handle in read_handles {
        handle.join().unwrap();
    }
    write_handle.join().unwrap();
}

use std::sync::{Mutex, MutexGuard};
use std::time::Duration;

pubfn deadlock_prevention() {
    let lock1 = Mutex::new(1);
    let lock2 = Mutex::new(2);
    
    // 使用固定的锁获取顺序预防死锁
    let handle1 = thread::spawn(move || {
        let _guard1 = lock1.lock().unwrap();
        thread::sleep(Duration::from_millis(100));
        let _guard2 = lock2.lock().unwrap();
        println!("线程1获取了所有锁");
    });
    
    let handle2 = thread::spawn(move || {
        let _guard1 = lock1.lock().unwrap(); // 同样的顺序
        thread::sleep(Duration::from_millis(100));
        let _guard2 = lock2.lock().unwrap();
        println!("线程2获取了所有锁");
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
}

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

pubfn channel_patterns() {
    // 多生产者单消费者通道
    let (tx, rx) = mpsc::channel();
    
    // 多个生产者
    for i in0..3 {
        let tx = tx.clone();
        thread::spawn(move || {
            for j in0..5 {
                tx.send(format!("生产者{}消息{}", i, j)).unwrap();
                thread::sleep(Duration::from_millis(100));
            }
        });
    }
    
    drop(tx); // 关闭原始发送者
    
    // 消费者接收所有消息
    whileletOk(msg) = rx.recv() {
        println!("收到: {}", msg);
    }
}

// 有界通道和同步通道
pubfn advanced_channels() {
    // 有界通道 - 防止内存无限增长
    let (bounded_tx, bounded_rx) = mpsc::sync_channel(10);
    
    // 同步通道 - 发送会阻塞直到接收
    let (sync_tx, sync_rx) = mpsc::sync_channel(0);
    
    thread::spawn(move || {
        for i in0..10 {
            bounded_tx.send(i).unwrap();
        }
    });
    
    thread::spawn(move || {
        sync_tx.send("同步消息").unwrap();
    });
    
    println!("有界通道: {}", bounded_rx.recv().unwrap());
    println!("同步通道: {}", sync_rx.recv().unwrap());
}

use tokio::sync::{Mutex, mpsc};
use tokio::time::{sleep, Duration};
use std::sync::Arc;

#[tokio::main]
asyncfn tokio_ecosystem() {
    // 异步互斥锁
    let counter = Arc::new(Mutex::new(0));
    
    letmut handles = vec![];
    for _ in0..10 {
        let counter = Arc::clone(&counter);
        let handle = tokio::spawn(asyncmove {
            letmut num = counter.lock().await;
            *num += 1;
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.await.unwrap();
    }
    
    println!("最终计数: {}", *counter.lock().await);
}

// 异步通道和任务管理
pubasyncfn async_channels() {
    let (tx, mut rx) = mpsc::channel(32);
    
    // 生产者任务
    let producer = tokio::spawn(asyncmove {
        for i in0..10 {
            tx.send(i).await.unwrap();
            sleep(Duration::from_millis(100)).await;
        }
    });
    
    // 消费者任务
    let consumer = tokio::spawn(asyncmove {
        whileletSome(message) = rx.recv().await {
            println!("收到异步消息: {}", message);
        }
    });
    
    let _ = tokio::join!(producer, consumer);
}

public class ThreadConfinement {
    // ThreadLocal实现线程封闭
    privatestaticfinal ThreadLocal<SimpleDateFormat> dateFormatThreadLocal =
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
    
    // 栈封闭 - 局部变量线程安全
    public void stackConfinement() {
        List<String> localList = new ArrayList<>(); // 每个线程有自己的副本
        localList.add("thread local data");
    }
    
    // 不可变对象模式
    publicfinalclass ImmutableValue {
        privatefinalint value;
        
        public ImmutableValue(int value) {
            this.value = value;
        }
        
        public int getValue() {
            return value;
        }
        
        public ImmutableValue add(int delta) {
            returnnew ImmutableValue(this.value + delta); // 返回新对象
        }
    }
}

pub mod ownership_patterns {
    use std::sync::Arc;
    use std::thread;
    
    // 基于消息传递的状态共享
    pubfn message_passing_state() {
        let (tx, rx) = std::sync::mpsc::channel();
        
        let state_manager = thread::spawn(move || {
            letmut state = 0;
            whileletOk(message) = rx.recv() {
                match message {
                    Message::Increment => state += 1,
                    Message::Decrement => state -= 1,
                    Message::Get(reply) => reply.send(state).unwrap(),
                }
            }
        });
        
        // 通过消息修改状态
        tx.send(Message::Increment).unwrap();
        
        let (reply_tx, reply_rx) = std::sync::mpsc::channel();
        tx.send(Message::Get(reply_tx)).unwrap();
        println!("当前状态: {}", reply_rx.recv().unwrap());
    }
    
    enum Message {
        Increment,
        Decrement,
        Get(std::sync::mpsc::Sender<i32>),
    }
    
    // 基于Actor模型的并发
    pubstruct ActorSystem {
        actors: Vec<Actor>,
    }
    
    impl ActorSystem {
        pubfn new() -> Self {
            ActorSystem { actors: Vec::new() }
        }
        
        pubfn spawn_actor<F>(&mutself, behavior: F) 
        where
            F: Fn(Message) -> Option<Message> + Send + 'static
        {
            // 实现Actor创建逻辑
        }
    }
}

public class JavaConcurrencyOptimization {
    // 使用LongAdder替代AtomicLong
    privatefinal LongAdder longAdder = new LongAdder();
    
    // 使用ConcurrentHashMap的分段锁
    privatefinal ConcurrentHashMap<String, String> concurrentMap = new ConcurrentHashMap<>();
    
    // 避免锁粗化
    public void avoidLockCoarsening() {
        // 错误的做法 - 不必要的粗粒度锁
        synchronized(this) {
            operation1();
            operation2();
            operation3();
        }
        
        // 正确的做法 - 细粒度锁
        operation1(); // 不需要同步的操作
        synchronized(this) {
            operation2(); // 需要同步的操作
        }
        operation3(); // 不需要同步的操作
    }
    
    // 使用读写锁优化读多写少场景
    privatefinal ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    
    public void readOptimizedOperation() {
        rwLock.readLock().lock();
        try {
            // 读取操作 - 多个线程可以同时执行
            readData();
        } finally {
            rwLock.readLock().unlock();
        }
    }
}

pub mod rust_concurrency_optimization {
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::thread;
    use std::time::Instant;
    
    // 使用原子操作替代锁
    pubfn atomic_optimization() {
        let counter = AtomicUsize::new(0);
        
        let handles: Vec<_> = (0..100).map(|_| {
            thread::spawn(move || {
                for _ in0..1000 {
                    counter.fetch_add(1, Ordering::Relaxed);
                }
            })
        }).collect();
        
        for handle in handles {
            handle.join().unwrap();
        }
        
        println!("最终计数: {}", counter.load(Ordering::Relaxed));
    }
    
    // 使用无锁数据结构
    pubstruct LockFreeStack<T> {
        head: AtomicPtr<Node<T>>,
    }
    
    impl<T> LockFreeStack<T> {
        pubfn new() -> Self {
            LockFreeStack { head: AtomicPtr::new(std::ptr::null_mut()) }
        }
                pubfn push(&self, value: T) {
            let new = Box::into_raw(Box::new(Node {
                data: value,
                next: AtomicPtr::new(std::ptr::null_mut()),
            }));

            loop {
                let old_head = self.head.load(Ordering::Acquire);
                unsafe { (*new).next.store(old_head, Ordering::Relaxed); }

                // CAS 把 new 变成新的 head
                matchself.head.compare_exchange(
                    old_head,
                    new,
                    Ordering::Release,
                    Ordering::Relaxed,
                ) {
                    Ok(_) => return,          // 成功
                    Err(_) => continue,       // 失败重试
                }
            }
        }

        pubfn pop(&self) -> Option<T> {
            loop {
                let old_head = self.head.load(Ordering::Acquire)?;
                let next = unsafe { (*old_head).next.load(Ordering::Relaxed) };

                // 尝试把 head 从 old_head 改成 next
                matchself.head.compare_exchange(
                    old_head,
                    next,
                    Ordering::Release,
                    Ordering::Relaxed,
                ) {
                    Ok(_) => {
                        // 独占旧头节点，安全解包
                        let node = unsafe { Box::from_raw(old_head) };
                        returnSome(node.data);
                    }
                    Err(_) => continue,
                }
            }
        }
    }

    struct Node<T> {
        data: T,
        next: AtomicPtr<Node<T>>,
    }

    // 读多写少场景：使用 RwLock 做细粒度读写分离
    use std::sync::RwLock;
    use std::collections::HashMap;

    pubfn read_mostly_cache() {
        let cache: RwLock<HashMap<u32, String>> = RwLock::new(HashMap::new());

        // 写线程
        let writer = thread::spawn(move || {
            for i in0..10 {
                letmut w = cache.write().unwrap();
                w.insert(i, format!("value-{i}"));
            }
        });

        // 多个读线程
        let readers: Vec<_> = (0..4)
            .map(|id| {
                thread::spawn(move || {
                    for _ in0..100_000 {
                        let r = cache.read().unwrap();
                        ifletSome(v) = r.get(&(id % 10)) {
                            std::hint::black_box(v);
                        }
                    }
                })
            })
            .collect();

        writer.join().unwrap();
        for r in readers {
            r.join().unwrap();
        }
    }

    // 跨线程无锁消息：使用 crossbeam-channel
    use crossbeam::channel;

    pubfn lock_free_channel() {
        let (tx, rx) = channel::unbounded::<u64>();

        let start = Instant::now();
        let prod = thread::spawn(move || {
            for i in0..1_000_000 {
                tx.send(i).unwrap();
            }
        });

        let cons = thread::spawn(move || {
            letmut sum = 0u64;
            whileletOk(v) = rx.recv() {
                sum += v;
            }
            sum
        });

        prod.join().unwrap();
        drop(tx); // 关闭发送端，让接收端正常退出
        let sum = cons.join().unwrap();
        println!("channel 1_000_000 项求和: {}，耗时 {:?}", sum, start.elapsed());
    }
}

public class JavaExceptionHierarchy {
    // 受检异常 - 必须在方法签名中声明或处理
    public void readFileWithCheckedException(String filename) 
        throws FileNotFoundException, IOException {
        
        try (FileReader reader = new FileReader(filename);
             BufferedReader br = new BufferedReader(reader)) {
            
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        }
        // FileNotFoundException 和 IOException 必须被处理或声明
    }
    
    // 非受检异常 - 不需要在方法签名中声明
    public void processWithUncheckedException(List<String> list) {
        if (list == null) {
            thrownew IllegalArgumentException("列表不能为null");
        }
        
        // 可能抛出 NullPointerException, IndexOutOfBoundsException
        String first = list.get(0);
        System.out.println(first.toUpperCase());
    }
}

public class CompleteExceptionHandling {
    private Connection connection;
    
    // 传统的try-catch-finally模式
    public void traditionalTryCatchFinally() {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test");
            stmt = conn.prepareStatement("SELECT * FROM users WHERE id = ?");
            stmt.setInt(1, 1);
            rs = stmt.executeQuery();
            
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
            
        } catch (SQLException e) {
            // 处理数据库异常
            System.err.println("数据库操作失败: " + e.getMessage());
            thrownew RuntimeException("数据访问失败", e);
            
        } finally {
            // 资源清理 - 确保执行
            try {
                if (rs != null) rs.close();
                if (stmt != null) stmt.close();
                if (conn != null) conn.close();
            } catch (SQLException e) {
                System.err.println("资源关闭失败: " + e.getMessage());
            }
        }
    }
    
    // try-with-resources 自动资源管理
    public void modernResourceManagement() {
        // 自动实现AutoCloseable的资源会在try块结束后自动关闭
        try (Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test");
             PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users");
             ResultSet rs = stmt.executeQuery()) {
            
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
            
        } catch (SQLException e) {
            // 处理异常，资源会自动关闭
            System.err.println("操作失败: " + e.getMessage());
            thrownew RuntimeException("数据访问失败", e);
        }
    }
}

// 自定义业务异常
publicclass BusinessException extends Exception {
    privatefinal String errorCode;
    privatefinal Map<String, Object> context;
    
    public BusinessException(String errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
        this.context = new HashMap<>();
    }
    
    public BusinessException(String errorCode, String message, Throwable cause) {
        super(message, cause);
        this.errorCode = errorCode;
        this.context = new HashMap<>();
    }
    
    public BusinessException addContext(String key, Object value) {
        this.context.put(key, value);
        returnthis;
    }
    
    // 获取完整的错误信息
    public String getDetailedMessage() {
        return String.format("[%s] %s - Context: %s", 
            errorCode, getMessage(), context);
    }
}

publicclass ExceptionChainingExample {
    public void processOrder(Order order) throws BusinessException {
        try {
            validateOrder(order);
            processPayment(order);
            updateInventory(order);
            
        } catch (ValidationException e) {
            thrownew BusinessException("VALIDATION_ERROR", "订单验证失败", e)
                .addContext("orderId", order.getId())
                .addContext("validationRule", e.getRule());
                
        } catch (PaymentException e) {
            thrownew BusinessException("PAYMENT_ERROR", "支付处理失败", e)
                .addContext("orderId", order.getId())
                .addContext("paymentMethod", order.getPaymentMethod());
                
        } catch (InventoryException e) {
            thrownew BusinessException("INVENTORY_ERROR", "库存更新失败", e)
                .addContext("orderId", order.getId())
                .addContext("productId", e.getProductId());
        }
    }
    
    private void validateOrder(Order order) throws ValidationException {
        // 验证逻辑
    }
    
    private void processPayment(Order order) throws PaymentException {
        // 支付处理
    }
    
    private void updateInventory(Order order) throws InventoryException {
        // 库存更新
    }
}

use std::fs::File;
use std::io::{self, Read, Write};
use std::path::Path;

// Result<T, E> 的基本定义
pubenum Result<T, E> {
    Ok(T),
    Err(E),
}

pubfn rust_result_basics() -> Result<String, io::Error> {
    // 打开文件可能失败，返回Result
    letmut file = File::open("example.txt")?; // ? 操作符自动传播错误
    
    letmut contents = String::new();
    file.read_to_string(&mut contents)?; // 读取可能失败
    
    Ok(contents) // 成功时返回Ok
}

// 自定义错误类型
#[derive(Debug)]
pubenum AppError {
    FileNotFound(String),
    ParseError(String),
    NetworkError(String),
}

impl std::fmt::Display for AppError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        matchself {
            AppError::FileNotFound(path) => write!(f, "文件未找到: {}", path),
            AppError::ParseError(details) => write!(f, "解析错误: {}", details),
            AppError::NetworkError(msg) => write!(f, "网络错误: {}", msg),
        }
    }
}

impl std::error::Error for AppError {}

pub fn option_patterns() {
    // Option<T> 的基本用法
    let some_value: Option<i32> = Some(42);
    let none_value: Option<i32> = None;
    
    // 安全地处理Option
    match some_value {
        Some(value) => println!("值为: {}", value),
        None => println!("没有值"),
    }
    
    // 使用unwrap要小心 - 可能panic
    let value = some_value.unwrap(); // 安全，因为有值
    // let bad = none_value.unwrap(); // panic!
    
    // 更安全的方式
    let safe_value = some_value.unwrap_or(0); // 提供默认值
    let or_else = none_value.unwrap_or_else(|| {
        println!("计算默认值");
        100
    });
}

// 实际应用中的Option链式操作
pubstruct User {
    pub name: String,
    pub email: Option<String>,
    pub profile: Option<Profile>,
}

pubstruct Profile {
    pub avatar: Option<String>,
    pub bio: Option<String>,
}

impl User {
    pubfn get_avatar_url(&self) -> Option<&str> {
        // 优雅的Option链式处理
        self.profile
            .as_ref()?    // 如果profile为None，直接返回None
            .avatar
            .as_ref()     // 如果avatar为None，返回None
            .map(|s| s.as_str())
    }
    
    pubfn get_bio_with_fallback(&self) -> String {
        self.profile
            .as_ref()
            .and_then(|p| p.bio.as_ref()) // 组合操作
            .map(|s| s.clone())
            .unwrap_or_else(|| "暂无个人简介".to_string())
    }
}

use std::fs;
use std::io;
use std::num::ParseIntError;

// 基本的错误传播
pubfn read_and_parse_file(path: &str) -> Result<i32, io::Error> {
    let content = fs::read_to_string(path)?; // 错误自动传播
    let number: i32 = content.trim().parse().map_err(|e: ParseIntError| {
        io::Error::new(io::ErrorKind::InvalidData, e)
    })?;
    Ok(number)
}

// 自定义错误类型的传播
pubfn complex_operation() -> Result<(), AppError> {
    let data = read_config_file("config.toml")?;
    let parsed = parse_config(&data)?;
    initialize_system(&parsed)?;
    Ok(())
}

fn read_config_file(path: &str) -> Result<String, AppError> {
    fs::read_to_string(path)
        .map_err(|e| AppError::FileNotFound(path.to_string()))
}

fn parse_config(data: &str) -> Result<Config, AppError> {
    // 解析逻辑
    todo!()
}

fn initialize_system(config: &Config) -> Result<(), AppError> {
    // 初始化逻辑
    todo!()
}

// Java风格 - 使用异常
publicclass JavaUserService {
    public User findUserById(String id) throws UserNotFoundException {
        User user = userRepository.findById(id);
        if (user == null) {
            thrownew UserNotFoundException("用户不存在: " + id);
        }
        return user;
    }
    
    public void updateUserEmail(String id, String email) 
        throws UserNotFoundException, InvalidEmailException {
        
        User user = findUserById(id);
        if (!isValidEmail(email)) {
            thrownew InvalidEmailException("邮箱格式无效: " + email);
        }
        user.setEmail(email);
        userRepository.save(user);
    }
}

// Rust风格 - 使用Result
pubstruct UserService {
    repository: UserRepository,
}

impl UserService {
    pubfn find_user_by_id(&self, id: &str) -> Result<User, UserError> {
        self.repository
            .find_by_id(id)
            .ok_or_else(|| UserError::NotFound(id.to_string()))
    }
    
    pubfn update_user_email(&self, id: &str, email: &str) -> Result<(), UserError> {
        letmut user = self.find_user_by_id(id)?;
        
        if !is_valid_email(email) {
            returnErr(UserError::InvalidEmail(email.to_string()));
        }
        
        user.email = email.to_string();
        self.repository.save(&user)?;
        
        Ok(())
    }
}

#[derive(Debug)]
pubenum UserError {
    NotFound(String),
    InvalidEmail(String),
    RepositoryError(String),
}

impl std::fmt::Display for UserError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        matchself {
            UserError::NotFound(id) => write!(f, "用户不存在: {}", id),
            UserError::InvalidEmail(email) => write!(f, "邮箱格式无效: {}", email),
            UserError::RepositoryError(msg) => write!(f, "数据访问错误: {}", msg),
        }
    }
}

impl std::error::Error for UserError {}

// Java - 自动资源管理
publicclass JavaResourceHandler {
    public void processFile(String inputPath, String outputPath) throws IOException {
        try (InputStream input = new FileInputStream(inputPath);
             OutputStream output = new FileOutputStream(outputPath)) {
            
            byte[] buffer = newbyte[1024];
            int bytesRead;
            while ((bytesRead = input.read(buffer)) != -1) {
                output.write(buffer, 0, bytesRead);
            }
        }
        // 资源自动关闭，即使发生异常
    }
}

// Rust - RAII (Resource Acquisition Is Initialization)
use std::fs::File;
use std::io::{self, Read, Write};

pubstruct FileProcessor;

impl FileProcessor {
    pubfn process_files(input_path: &str, output_path: &str) -> io::Result<()> {
        // File 实现了Drop trait，离开作用域时自动关闭
        letmut input_file = File::open(input_path)?;
        letmut output_file = File::create(output_path)?;
        
        letmut buffer = [0u8; 1024];
        loop {
            let bytes_read = input_file.read(&mut buffer)?;
            if bytes_read == 0 {
                break;
            }
            output_file.write_all(&buffer[..bytes_read])?;
        }
        
        Ok(())
        // 文件在这里自动关闭，无需finally块
    }
}

// 自定义RAII类型
pubstruct ManagedConnection {
    url: String,
    // 连接资源
}

impl ManagedConnection {
    pubfn new(url: &str) -> Result<Self, ConnectionError> {
        // 建立连接
        Ok(ManagedConnection {
            url: url.to_string(),
        })
    }
    
    pubfn execute_query(&self, query: &str) -> Result<(), ConnectionError> {
        // 执行查询
        Ok(())
    }
}

// 实现Drop trait确保资源清理
implDropfor ManagedConnection {
    fn drop(&mutself) {
        // 自动关闭连接
        println!("关闭连接: {}", self.url);
    }
}

use thiserror::Error;

// 使用thiserror库简化错误定义
#[derive(Error, Debug)]
pubenum ApplicationError {
    #[error("数据库错误: {source}")]
    Database {
        #[from]
        source: sqlx::Error,
    },
    
    #[error("配置错误: {message}")]
    Configuration { message: String },
    
    #[error("网络错误: {url} - {source}")]
    Network {
        url: String,
        #[source]
        source: reqwest::Error,
    },
    
    #[error("验证错误: {field} - {reason}")]
    Validation { field: String, reason: String },
}

// 错误转换实现
impl ApplicationError {
    pubfn validation(field: &str, reason: &str) -> Self {
        ApplicationError::Validation {
            field: field.to_string(),
            reason: reason.to_string(),
        }
    }
    
    pubfn configuration(message: implInto<String>) -> Self {
        ApplicationError::Configuration {
            message: message.into(),
        }
    }
}

// 统一的错误处理中间件
pubasyncfn error_handler_middleware(
    req: Request<Body>,
    next: Next<Body>,
) -> Result<Response<Body>, ApplicationError> {
    let result = next.run(req).await;
    
    match result {
        Ok(response) => Ok(response),
        Err(err) => {
            // 统一错误处理和日志记录
            log::error!("请求处理失败: {:?}", err);
            
            // 转换为适当的HTTP响应
            let status = match err.downcast_ref::<ApplicationError>() {
                Some(ApplicationError::Validation { .. }) => StatusCode::BAD_REQUEST,
                Some(ApplicationError::Configuration { .. }) => StatusCode::INTERNAL_SERVER_ERROR,
                _ => StatusCode::INTERNAL_SERVER_ERROR,
            };
            
            let error_response = ErrorResponse::new(status, err.to_string());
            Ok(error_response.into())
        }
    }
}

use std::num::ParseIntError;

/// 立即失败策略：只要出现一次解析失败，整体就返回 Err
fn parse_all_fail_fast(strs: &[&str]) -> Result<Vec<i32>, ParseIntError> {
    strs.iter()
        .map(|s| s.parse::<i32>())          // Iterator<Item = Result<i32, _>>
        .collect()                          // Vec<Result<i32, _>> -> Result<Vec<i32>, _>
}

/// 收集全部错误策略：成功与失败分开收集
fn parse_all_collect_errors(strs: &[&str]) -> (Vec<i32>, Vec<String>) {
    strs.iter()
        // 把 &str 先变成 String，方便后续收集错误信息
        .map(|s| s.parse::<i32>().map_err(|_| s.to_string()))
        // 用 partition 把 Ok / Err 分流
        .partition(Result::is_ok)
        // 把 (Vec<Result<i32, String>>, Vec<Result<i32, String>>) 变成 (Vec<i32>, Vec<String>)
        .0.into_iter().flatten().collect::<Vec<_>>(),
        .1.into_iter().flatten().collect::<Vec<_>>()
}

/// 演示组合子：map、filter_map、and_then、unwrap_or、transpose 等
fn combinator_demo() {
    let numbers = vec!["1", "2", "3", "four", "5"];

    // 1. 用 filter_map 把合法数字留下，非法的直接丢弃
    let only_ok: Vec<i32> = numbers
        .iter()
        .filter_map(|s| s.parse::<i32>().ok())
        .collect();
    println!("only_ok = {only_ok:?}"); // [1, 2, 3, 5]

    // 2. 用 map + transpose 把 Vec<Result<T, E>> 变成 Result<Vec<T>, E>
    let results: Vec<Result<i32, _>> = numbers.iter().map(|s| s.parse::<i32>()).collect();
    let collected: Result<Vec<i32>, _> = results.into_iter().collect();
    println!("collected = {collected:?}"); // Err(ParseIntError { ... })

    // 3. 用 unwrap_or 给非法值一个默认值
    let with_default: Vec<i32> = numbers
        .iter()
        .map(|s| s.parse::<i32>().unwrap_or(-1))
        .collect();
    println!("with_default = {with_default:?}"); // [1, 2, 3, -1, 5]

    // 4. and_then 链式校验：解析后只保留偶数
    let even_only: Vec<i32> = numbers
        .iter()
        .filter_map(|s| {
            s.parse::<i32>()
                .and_then(|n| if n % 2 == 0 { Ok(n) } else { Err(ParseIntError {}) })
                .ok()
        })
        .collect();
    println!("even_only = {even_only:?}"); // [2]
}

fn main() {
    combinator_demo();

    let data = ["10", "20", "oops", "30"];
    match parse_all_fail_fast(&data) {
        Ok(nums) => println!("fail_fast success: {nums:?}"),
        Err(e)   => println!("fail_fast error: {e}"),
    }

    let (oks, errs) = parse_all_collect_errors(&data);
    println!("collect_errors: oks={oks:?}, errs={errs:?}");
}

<!-- 父POM统一依赖管理 -->
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>
    
    <modules>
        <module>api</module>
        <module>service</module>
        <module>web</module>
    </modules>
    
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.7.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

// settings.gradle.kts
rootProject.name = "enterprise-app"
include(":domain", ":application", ":infrastructure", ":web")

// build.gradle.kts
plugins {
    java
    id("org.springframework.boot") version "2.7.0"
    id("io.spring.dependency-management") version "1.0.11.RELEASE"
}

subprojects {
    apply(plugin = "java")
    apply(plugin = "io.spring.dependency-management")
    
    repositories {
        mavenCentral()
        gradlePluginPortal()
    }
    
    dependencies {
        implementation("org.springframework.boot:spring-boot-starter")
        testImplementation("org.springframework.boot:spring-boot-starter-test")
    }
    
    tasks.test {
        useJUnitPlatform()
        testLogging {
            events("passed", "failed", "skipped")
            showStandardStreams = true
        }
    }
}

# 多阶段构建优化镜像大小
FROM eclipse-temurin:17-jdk-jammy as builder
WORKDIR /app
COPY . .
RUN ./gradlew build -x test

FROM eclipse-temurin:17-jre-jammy as runtime
RUN addgroup --system javauser && adduser --system --ingroup javauser javauser

WORKDIR /app
COPY --from=builder /app/build/libs/*.jar app.jar

# JVM调优参数
ENV JAVA_OPTS="-XX:+UseContainerSupport \
               -XX:MaxRAMPercentage=75.0 \
               -XX:+UseG1GC \
               -XX:MaxGCPauseMillis=200 \
               -Xlog:gc*:file=/app/logs/gc.log:time,uptime,level,tags:filecount=5,filesize=10m"

# 安全最佳实践
RUN chown -R javauser:javauser /app
USER javauser

EXPOSE8080
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar /app/app.jar"]

apiVersion: apps/v1
kind:Deployment
metadata:
name:java-app
labels:
    app:java-app
spec:
replicas:3
selector:
    matchLabels:
      app:java-app
template:
    metadata:
      labels:
        app:java-app
      annotations:
        prometheus.io/scrape:"true"
        prometheus.io/port:"8080"
        prometheus.io/path:"/actuator/prometheus"
    spec:
      containers:
      -name:java-app
        image:registry.example.com/java-app:1.0.0
        ports:
        -containerPort:8080
        env:
        -name:SPRING_PROFILES_ACTIVE
          value:"production"
        resources:
          requests:
            memory:"512Mi"
            cpu:"250m"
          limits:
            memory:"1Gi"
            cpu:"500m"
        livenessProbe:
          httpGet:
            path:/actuator/health
            port:8080
          initialDelaySeconds:60
          periodSeconds:10
        readinessProbe:
          httpGet:
            path:/actuator/health/readiness
            port:8080
          initialDelaySeconds:30
          periodSeconds:5
---
apiVersion:v1
kind:Service
metadata:
name:java-app-service
spec:
selector:
    app:java-app
ports:
-port:80
    targetPort:8080
type:ClusterIP

# application-prod.yml
management:
endpoints:
    web:
      exposure:
        include:"health,info,metrics,prometheus"
    jmx:
      exposure:
        include:"*"
endpoint:
    health:
      show-details:always
      show-components:always
      probes:
        enabled:true
    metrics:
      enabled:true
metrics:
    export:
      prometheus:
        enabled:true
    distribution:
      percentiles-histogram:
        http.server.requests:true
tracing:
    sampling:
      probability:0.1

@Configuration
@EnableAspectJAutoProxy
publicclass MonitoringConfig {
    
    @Bean
    public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
        return registry -> registry.config().commonTags(
            "application", "java-app",
            "environment", "production",
            "region", System.getenv("REGION")
        );
    }
    
    @Bean
    public TimedAspect timedAspect(MeterRegistry registry) {
        returnnew TimedAspect(registry);
    }
}

@Service
publicclass OrderService {
    
    @Timed(value = "order.process", description = "订单处理时间")
    @Counted(value = "order.requests", description = "订单请求计数")
    public Order processOrder(OrderRequest request) {
        // 业务逻辑
        return order;
    }
}

[package]
name = "production-service"
version = "0.1.0"
edition = "2021"
authors = ["Team <team@example.com>"]
description = "高性能Rust生产服务"
license = "MIT OR Apache-2.0"
readme = "README.md"
repository = "https://github.com/example/production-service"
homepage = "https://example.com"

# 优化发布构建
[profile.release]
codegen-units = 1
lto = true
panic = "abort"
incremental = false
opt-level = 3
debug = false

# 开发配置
[profile.dev]
opt-level = 0
debug = true
incremental = true

# 测试配置
[profile.test]
opt-level = 0
debug = true

[dependencies]
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
reqwest = { version = "0.11", features = ["json"] }
sqlx = { version = "0.6", features = ["postgres", "runtime-tokio-rustls"] }
tracing = "0.1"
tracing-subscriber = "0.3"
thiserror = "1.0"

# 可选依赖
[features]
default = ["postgres", "redis"]
postgres = ["sqlx/postgres"]
redis = ["bb8", "bb8-redis"]
jemalloc = ["tikv-jemallocator"]

# 开发依赖
[dev-dependencies]
rstest = "0.16"
mockall = "0.11"
testcontainers = "0.14"

# 工作区配置
[workspace]
members = ["crates/*"]
resolver = "2"

# .cargo/config.toml
[build]
rustflags = ["-D", "warnings"]

[alias]
lint = "clippy -- -W clippy::all -W clippy::pedantic -W clippy::nursery -W clippy::cargo"
fix = "clippy --fix --allow-dirty --allow-staged"

# clippy.toml
avoid-breaking-exported-api = false
too-many-arguments-threshold = 8
type-complexity-threshold = 25

# .github/workflows/ci.yml
name:CIPipeline

on:
push:
    branches:[main,develop]
pull_request:
    branches:[main]

jobs:
quality:
    runs-on:ubuntu-latest
    steps:
    -uses:actions/checkout@v3
    
    -name:InstallRust
      uses:actions-rs/toolchain@v1
      with:
        toolchain:stable
        components:clippy,rustfmt
        override:true
    
    -name:Cachecargoregistry
      uses:actions/cache@v3
      with:
        path:|
          ~/.cargo/registry
          ~/.cargo/git
          target
        key:${{runner.os}}-cargo-${{hashFiles('**/Cargo.lock')}}
    
    -name:Checkformatting
      run:cargofmt----check
    
    -name:Clippyanalysis
      run:cargoclippy---Dwarnings
    
    -name:Runtests
      run:cargotest
    
    -name:Securityaudit
      run:cargoaudit
    
    -name:Buildrelease
      run:cargobuild--release

# 多架构构建Dockerfile
FROM --platform=$BUILDPLATFORM rust:1.67 as planner
WORKDIR /app
RUN cargo install cargo-chef
COPY . .
RUN cargo chef prepare --recipe-path recipe.json

FROM --platform=$BUILDPLATFORM rust:1.67 as builder
WORKDIR /app
RUN cargo install cargo-chef
COPY --from=planner /app/recipe.json recipe.json
RUN cargo chef cook --release --recipe-path recipe.json
COPY . .
RUN cargo build --release --bin production-service

FROM gcr.io/distroless/cc-debian11:nonroot as runtime
WORKDIR /app
COPY --from=builder /app/target/release/production-service /app/
USER nonroot:nonroot
EXPOSE8080
ENTRYPOINT ["./production-service"]

# .cargo/config.toml
[target.x86_64-unknown-linux-musl]
linker = "x86_64-linux-musl-gcc"

[target.aarch64-unknown-linux-gnu]
linker = "aarch64-linux-gnu-gcc"

[build]
target-dir = "target/cross"

#!/bin/bash
# build-multiarch.sh
set -e

TARGETS=(
    "x86_64-unknown-linux-gnu"
    "x86_64-unknown-linux-musl"
    "aarch64-unknown-linux-gnu"
    "x86_64-pc-windows-gnu"
)

for target in"${TARGETS[@]}"; do
    echo"Building for $target"
    cargo build --release --target $target
    strip "target/$target/release/production-service" 2>/dev/null || true
done

use tracing::{info, error, warn, Level};
use tracing_subscriber::{fmt, prelude::*, EnvFilter};

pubfn setup_tracing() -> Result<(), Box<dyn std::error::Error>> {
    let fmt_layer = fmt::layer()
        .with_target(false)
        .with_timer(fmt::time::UtcTime::rfc_3339())
        .with_writer(std::io::stdout);
    
    let filter_layer = EnvFilter::try_from_default_env()
        .or_else(|_| EnvFilter::try_new("info"))?;
    
    tracing_subscriber::registry()
        .with(filter_layer)
        .with(fmt_layer)
        .with(tracing_opentelemetry::layer())
        .init();
    
    Ok(())
}

#[tracing::instrument]
pubasyncfn process_request(request: &Request) -> Result<Response, Error> {
    info!("Processing request: {:?}", request);
    
    let result = business_logic(request).await?;
    
    metrics::counter!("requests.processed", 1);
    Ok(result)
}

use prometheus::{Counter, Encoder, Gauge, Histogram, Registry, TextEncoder};

lazy_static! {
    pubstaticref REGISTRY: Registry = Registry::new();
    pubstaticref REQUESTS_TOTAL: Counter = register_counter!(
        "http_requests_total",
        "Total HTTP requests",
        &["method", "endpoint", "status"]
    ).unwrap();
    pubstaticref REQUEST_DURATION: Histogram = register_histogram!(
        "http_request_duration_seconds",
        "HTTP request duration",
        vec![0.01, 0.05, 0.1, 0.5, 1.0, 2.0, 5.0]
    ).unwrap();
    pubstaticref CONNECTIONS_ACTIVE: Gauge = register_gauge!(
        "database_connections_active",
        "Active database connections"
    ).unwrap();
}

pubasyncfn metrics_handler() -> impl warp::Reply {
    let encoder = TextEncoder::new();
    let metric_families = REGISTRY.gather();
    letmut buffer = vec![];
    encoder.encode(&metric_families, &mut buffer).unwrap();
    
    String::from_utf8(buffer).unwrap()
}

name: JavaCI/CD

on:
push:
    branches:[main]
pull_request:
    branches:[main]

jobs:
test:
    runs-on:ubuntu-latest
    services:
      postgres:
        image:postgres:14
        env:
          POSTGRES_PASSWORD:test
        options:>-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        ports:
          -5432:5432

    steps:
    -uses:actions/checkout@v3
    
    -name:SetupJDK17
      uses:actions/setup-java@v3
      with:
        java-version:'17'
        distribution:'temurin'
        cache:'gradle'
    
    -name:Grantexecutepermissionforgradlew
      run:chmod+xgradlew
    
    -name:Buildandtest
      run:./gradlewbuild
      env:
        SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5432/postgres
    
    -name:Codecoverage
      uses:codecov/codecov-action@v2
      with:
        file:./build/reports/jacoco/test/jacocoTestReport.xml

security:
    runs-on:ubuntu-latest
    steps:
    -uses:actions/checkout@v3
    
    -name:RunSnyktocheckforvulnerabilities
      uses:snyk/actions/gradle@master
      env:
        SNYK_TOKEN:${{secrets.SNYK_TOKEN}}
    
    -name:Dependencycheck
      run:./gradlewdependencyCheckAnalyze

deploy:
    needs:[test,security]
    runs-on:ubuntu-latest
    if:github.ref=='refs/heads/main'
    
    steps:
    -uses:actions/checkout@v3
    
    -name:BuildDockerimage
      run:|
        docker build -t ${{ secrets.REGISTRY }}/java-app:${{ github.sha }} .
    
    -name:Pushtoregistry
      run:|
        echo ${{ secrets.REGISTRY_PASSWORD }} | docker login -u ${{ secrets.REGISTRY_USERNAME }} --password-stdin
        docker push ${{ secrets.REGISTRY }}/java-app:${{ github.sha }}
    
    -name:DeploytoKubernetes
      run: |
        kubectl set image deployment/java-app java-app=${{ secrets.REGISTRY }}/java-app:${{ github.sha }}

# .gitlab-ci.yml
stages:
-test
-security
-build
-deploy

variables:
CARGO_HOME:$CI_PROJECT_DIR/.cargo

.cache: &global