Java线程方法之从线程角色到实战避坑指南

public class joindemo1 {
    // 共享变量存储子线程的计算结果
    private static int sum = 0;

    public static void main(string[] args) throws interruptedexception {
        // 目标线程：计算1-100的和
        thread calcthread = new thread(() -> {
            for (int i = 1; i <= 100; i++) {
                sum += i;
            }
            system.out.println("目标线程（calcthread）：计算完成，sum=" + sum);
        });

        // 启动目标线程
        calcthread.start();
        // 当前线程（主线程）等待目标线程计算完成
        calcthread.join();

        // 当前线程（主线程）使用目标线程的结果
        system.out.println("当前线程（主线程）：拿到结果，sum=" + sum);
    }
}

public class joindemo2 {
    public static void main(string[] args) throws interruptedexception {
        // 创建3个目标线程（下载线程）
        thread t1 = new thread(() -> system.out.println("目标线程（t1）：文件1下载完成"), "下载线程1");
        thread t2 = new thread(() -> system.out.println("目标线程（t2）：文件2下载完成"), "下载线程2");
        thread t3 = new thread(() -> system.out.println("目标线程（t3）：文件3下载完成"), "下载线程3");

        // 启动所有目标线程
        t1.start();
        t2.start();
        t3.start();

        // 当前线程（主线程）等待所有目标线程完成
        t1.join();
        t2.join();
        t3.join();

        // 当前线程（主线程）汇总结果
        system.out.println("当前线程（主线程）：所有文件下载完成，开始合并文件！");
    }
}

public class sleepdemo1 {
    public static void main(string[] args) {
        // 验证码倒计时60秒
        int count = 60;
        while (count > 0) {
            system.out.println("当前线程（主线程）：验证码倒计时：" + count + "秒");
            try {
                // 当前线程（主线程）暂停1秒
                thread.sleep(1000);
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
            count--;
        }
        system.out.println("当前线程（主线程）：验证码已过期，请重新获取！");
    }
}

public class sleepdemo2 {
    public static void main(string[] args) {
        // 模拟一个持续运行的监控线程（当前线程）
        thread monitorthread = new thread(() -> {
            while (true) {
                // 执行监控逻辑
                system.out.println("当前线程（monitorthread）：监控系统运行中...");
                try {
                    // 当前线程（monitorthread）每隔5秒监控一次
                    thread.sleep(5000);
                } catch (interruptedexception e) {
                    e.printstacktrace();
                    // 被中断时退出循环
                    break;
                }
            }
        });
        monitorthread.start();
    }
}

public class waitnotifydemo {
    // 共享队列（用数组模拟，容量为3）
    private static final int[] queue = new int[3];
    // 队列当前元素个数
    private static int count = 0;
    // 锁对象（所有线程共用同一个锁）
    private static final object lock = new object();

    // 生产者线程：生产产品（往队列加元素）
    static class producer extends thread {
        @override
        public void run() {
            while (true) {
                synchronized (lock) {
                    // 队列满，当前线程（生产者）成为等待线程，等待消费者唤醒
                    while (count == queue.length) {
                        try {
                            system.out.println("当前线程（生产者）：队列满，等待消费者消费...");
                            lock.wait();
                        } catch (interruptedexception e) {
                            e.printstacktrace();
                        }
                    }
                    // 生产产品
                    queue[count] = (int) (math.random() * 100);
                    system.out.println("当前线程（生产者）：生产" + queue[count]);
                    count++;
                    // 当前线程（生产者）成为唤醒线程，唤醒等待的消费者
                    lock.notifyall();
                }
                // 模拟生产间隔
                try {
                    thread.sleep(500);
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
            }
        }
    }

    // 消费者线程：消费产品（从队列取元素）
    static class consumer extends thread {
        @override
        public void run() {
            while (true) {
                synchronized (lock) {
                    // 队列空，当前线程（消费者）成为等待线程，等待生产者唤醒
                    while (count == 0) {
                        try {
                            system.out.println("当前线程（消费者）：队列空，等待生产者生产...");
                            lock.wait();
                        } catch (interruptedexception e) {
                            e.printstacktrace();
                        }
                    }
                    // 消费产品
                    count--;
                    system.out.println("当前线程（消费者）：消费" + queue[count]);
                    // 当前线程（消费者）成为唤醒线程，唤醒等待的生产者
                    lock.notifyall();
                }
                // 模拟消费间隔
                try {
                    thread.sleep(800);
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
            }
        }
    }

    public static void main(string[] args) {
        // 启动1个生产者、1个消费者
        new producer().start();
        new consumer().start();
    }
}

public class waitnotifydemo2 {
    // 初始化完成标记
    private static boolean initdone = false;
    // 锁对象
    private static final object lock = new object();

    public static void main(string[] args) {
        // 等待线程（当前线程）：workthread子线程，等待初始化完成
        thread workthread = new thread(() -> {
            synchronized (lock) {
                // 等待初始化完成
                while (!initdone) {
                    try {
                        system.out.println("当前线程（workthread）：等待初始化...");
                        lock.wait();
                    } catch (interruptedexception e) {
                        e.printstacktrace();
                    }
                }
                system.out.println("当前线程（workthread）：初始化完成，开始工作！");
            }
        });
        workthread.start();

        // 唤醒线程（目标线程）：主线程，执行初始化并唤醒子线程
        try {
            thread.sleep(2000); // 模拟初始化耗时
            synchronized (lock) {
                initdone = true;
                system.out.println("当前线程（主线程）：初始化完成，唤醒子线程！");
                lock.notifyall();
            }
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
    }
}

public class yielddemo {
    // 业务线程（高优先级，处理核心逻辑）
    static class businessthread extends thread {
        public businessthread() {
            // 设置高优先级（1-10，默认5）
            setpriority(thread.max_priority);
        }

        @override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                system.out.println("业务线程：处理订单" + i);
            }
        }
    }

    // 统计线程（低优先级，后台统计）：当前线程，执行yield()让步
    static class statthread extends thread {
        public statthread() {
            // 设置低优先级
            setpriority(thread.min_priority);
        }

        @override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                // 当前线程（statthread）主动让步，让业务线程先执行
                thread.yield();
                system.out.println("当前线程（statthread）：统计订单" + i);
            }
        }
    }

    public static void main(string[] args) {
        new businessthread().start();
        new statthread().start();
    }
}

import java.util.concurrent.locks.locksupport;

public class locksupportdemo1 {
    public static void main(string[] args) {
        // 阻塞线程（当前线程）：workthread子线程
        thread workthread = new thread(() -> {
            system.out.println("当前线程（workthread）：开始执行，准备阻塞...");
            // 当前线程（workthread）阻塞自身
            locksupport.park();
            system.out.println("当前线程（workthread）：被唤醒，继续执行！");
        }, "工作线程");
        workthread.start();

        // 唤醒线程（主线程）：延迟2秒后唤醒目标线程（workthread）
        try {
            thread.sleep(2000);
            system.out.println("当前线程（主线程）：唤醒目标线程（workthread）！");
            locksupport.unpark(workthread);
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
    }
}

import java.util.concurrent.locks.locksupport;

public class locksupportdemo2 {
    public static void main(string[] args) {
        // 阻塞线程（当前线程）：workthread子线程
        thread workthread = new thread(() -> {
            // 先被unpark，再park（不会阻塞）
            system.out.println("当前线程（workthread）：准备阻塞...");
            locksupport.park();
            system.out.println("当前线程（workthread）：执行完成！");
        });

        // 唤醒线程（主线程）：先执行unpark，唤醒目标线程（workthread）
        locksupport.unpark(workthread);
        system.out.println("当前线程（主线程）：先执行unpark()，唤醒目标线程（workthread）");

        // 启动阻塞线程
        workthread.start();
    }
}