多线程

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + " 在运行: " + i);
        }
    }
}
	// 启动：new MyThread().start();
	优点:代码简单，直接 `this` 就能获取线程名。
	缺点：Java 是单继承，继承了 Thread 就不能继承别的类了。

public class MyRun implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 执行中");
    }
}
	// 启动：new Thread(new MyRun()).start();
	优点：扩展性强，可以实现接口的同时继承别的类；适合多个线程处理同一个资源。

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return 100 + 200; // 返回计算结果
    }
}
	// 启动需配合 FutureTask
	特点：可以获取线程执行后的结果，还能抛出异常。
	

public class MyThread extends Thread {  
    static int sum = 0;  
    //锁对象，一定要是唯一的
    static final Object obj = new Object();  
  
    @Override  
    public void run() {  
        while (true) {  
            synchronized (obj) {  
                // 核心：在锁内部再次判断，保证原子性  
                if (sum < 100) {  
                    try {  
                        Thread.sleep(100); // 模拟网络延迟或出票时间  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                    sum++;  
                    System.out.println(getName()+"正在卖第"+sum+"张票!");  
                } else {  
                    // 票卖完了，跳出死循环  
                    break;  
                }  
            }  
        }  
    }  
}

public class MyThread extends Thread {
    static int sum = 0;
    static Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            // 1. 锁放在 try 外面
            lock.lock(); 
            try {
                if (sum < 100) {
                    Thread.sleep(10); 
                    sum++;
					sout(getName() + "正在卖第" + sum + "张票!");
                } else {
                    // 2. 票卖完了，跳出循环
                    break; 
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 3. 无论如何都会还锁
                lock.unlock(); 
            }
        }
    }
}

//定义中间控制类（Buffer）
public class Desk {
    // 0: 没有饭, 1: 有饭
    public static int foodFlag = 0;
    // 锁对象
    public static final Object lock = new Object();
}

//消费者
public void run() {
    while (true) {
        synchronized (Desk.lock) {
            if (Desk.foodFlag == 0) {
                try { Desk.lock.wait(); } catch (Exception e) {} // 没饭就等
            } else {
                System.out.println("吃货：开炫！");
                Desk.foodFlag = 0; // 吃完了
                Desk.lock.notifyAll(); // 叫醒厨师再做点
            }
        }
    }
}

//生产者
public void run() {
    while (true) {
        synchronized (Desk.lock) {
            if (Desk.foodFlag == 1) {
                try { Desk.lock.wait(); } catch (Exception e) {} // 有饭就歇着
            } else {
                System.out.println("厨师：出锅一份回锅肉！");
                Desk.foodFlag = 1; // 饭好了
                Desk.lock.notifyAll(); // 叫醒吃货开饭
            }
        }
    }
}

//生产者
public class Cook extends Thread {
    private BlockingQueue<String> queue;
    public Cook(BlockingQueue<String> queue) { this.queue = queue; }

    @Override
    public void run() {
        while (true) {
            try {
                // put 方法自带阻塞逻辑：如果队列满了，就在这儿等
                queue.put("回锅肉");
                System.out.println("厨师放了一份回锅肉，当前库存：" + queue.size());
            } catch (InterruptedException e) { e.printStackTrace(); }
        }
    }
}

//消费者
public class Foodie extends Thread {
    private BlockingQueue<String> queue;
    public Foodie(BlockingQueue<String> queue) { this.queue = queue; }

    @Override
    public void run() {
        while (true) {
            try {
                // take 方法自带阻塞逻辑：如果队列空了，就在这儿等
                String food = queue.take();
                System.out.println("吃货炫了一份：" + food);
            } catch (InterruptedException e) { e.printStackTrace(); }
        }
    }
}

//测试类（连接两者）
// 创建一个只能装 1 份饭的阻塞队列
BlockingQueue<String> queue = new ArrayBlockingQueue<>(1);

new Cook(queue).start();
new Foodie(queue).start();

ThreadPoolExecutor pool = new ThreadPoolExecutor(  
        3,  //核心线程数量  不能小于0  
        6,  //最大线程数量  不能小于0 且>=核心线程数量  
        60, //空闲线程最大存活时间  
        TimeUnit.SECONDS, //空闲线程最大存活时间的单位  
        new ArrayBlockingQueue<>(3),//任务队列 不能为null  
        Executors.defaultThreadFactory(),//线程工厂 不能为null  
        new ThreadPoolExecutor.AbortPolicy()//拒绝策略 不能为null  
);
	任务 1~3：直接创建 3 个核心线程（正式工）开始干活
	
	任务 4~6：核心线程已满，3 个任务进入 ArrayBlockingQueue（等候区）排队
	
	任务 7~9：等候区已满，线程池开启 3 个临时线程（临时工），总线程数达到 maximumPoolSize 6 个并开始干活
	
	任务 10：核心线程、队列、临时线程均已满，触发 AbortPolicy 拒绝策略，程序抛出 RejectedExecutionException 异常