Java 多线程编程：让程序同时干多件事

import java.util.Map;

public class ThreadListDemo {
    public static void main(String[] args) {
        // getAllStackTraces 可以拿到当前 JVM 中所有存活线程的信息
        Map<Thread, StackTraceElement[]> threadMap = Thread.getAllStackTraces();

        for (Thread thread : threadMap.keySet()) {
            System.out.println(thread.getName());
        }
    }
}

public class MyThread extends Thread {
    /**
     * 定义线程要执行的任务。
     */
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(getName() + " 正在执行：" + i);
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("线程A");
        t2.setName("线程B");

        // start 会开启新线程，并由 JVM 自动调用 run 方法
        t1.start();
        t2.start();
    }
}

t1.start(); // 正确：开启一条新的执行路径
t1.run();   // 错误理解：这只是普通方法调用，不会创建新线程

public class MyRunnable implements Runnable {
    /**
     * 定义线程任务，Runnable 本身不代表线程，只代表可执行任务。
     */
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + " 正在执行：" + i);
        }
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        MyRunnable task = new MyRunnable();

        Thread t1 = new Thread(task, "线程A");
        Thread t2 = new Thread(task, "线程B");

        t1.start();
        t2.start();
    }
}

Thread thread = new Thread(() -> {
    System.out.println(Thread.currentThread().getName() + " 执行任务");
}, "工作线程");

thread.start();

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableDemo {
    public static void main(String[] args) throws Exception {
        Callable<Integer> task = new Callable<Integer>() {
            /**
             * 计算 1 到 100 的和，并把结果返回给调用方。
             */
            @Override
            public Integer call() {
                int sum = 0;
                for (int i = 1; i <= 100; i++) {
                    sum += i;
                }
                return sum;
            }
        };

        FutureTask<Integer> futureTask = new FutureTask<>(task);
        Thread thread = new Thread(futureTask, "计算线程");
        thread.start();

        // get 会阻塞等待，直到线程执行完成并返回结果
        Integer result = futureTask.get();
        System.out.println("计算结果：" + result);
    }
}

public class ThreadMethodDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            Thread current = Thread.currentThread();
            System.out.println("当前线程对象：" + current);
            System.out.println("当前线程名称：" + current.getName());
        });

        thread.setName("下载线程");
        thread.start();

        System.out.println("main 方法由 " + Thread.currentThread().getName() + " 执行");
    }
}

public class SleepDemo {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 3; i >= 1; i--) {
            System.out.println(i);

            // 让当前 main 线程休眠 1 秒
            Thread.sleep(1000);
        }

        System.out.println("开始执行");
    }
}

public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            for (int i = 1; i <= 3; i++) {
                System.out.println("子线程执行：" + i);
            }
        });

        worker.start();

        // main 线程会等待 worker 执行结束后再继续往下走
        worker.join();

        System.out.println("子线程结束后，main 线程继续执行");
    }
}

public class DaemonDemo {
    public static void main(String[] args) {
        Thread daemon = new Thread(() -> {
            while (true) {
                System.out.println("后台守护线程运行中");
            }
        });

        // 守护线程会随着所有非守护线程结束而结束
        daemon.setDaemon(true);
        daemon.start();

        System.out.println("main 线程结束");
    }
}

public class TicketTask implements Runnable {
    private int tickets = 100;

    /**
     * 多个线程共享同一个 TicketTask 对象，因此共享 tickets 变量。
     */
    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出第 " + tickets + " 张票");
                tickets--;
            } else {
                break;
            }
        }
    }
}

public class SafeTicketTask implements Runnable {
    private int tickets = 100;
    private final Object lock = new Object();

    /**
     * 使用同步代码块保护共享变量 tickets。
     */
    @Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + " 卖出第 " + tickets + " 张票");
                    tickets--;
                } else {
                    break;
                }
            }
        }
    }
}

synchronized (锁对象) {
    // 操作共享数据的代码
}

public class SyncMethodTicketTask implements Runnable {
    private int tickets = 100;

    /**
     * 线程任务：循环调用同步方法卖票。
     */
    @Override
    public void run() {
        while (sellTicket()) {
            // 循环卖票，直到 sellTicket 返回 false
        }
    }

    /**
     * 同步方法会自动加锁，普通成员方法默认锁对象是 this。
     *
     * @return 还有票并成功卖出时返回 true，没有票时返回 false。
     */
    private synchronized boolean sellTicket() {
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + " 卖出第 " + tickets + " 张票");
            tickets--;
            return true;
        }
        return false;
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTicketTask implements Runnable {
    private int tickets = 100;
    private final Lock lock = new ReentrantLock();

    /**
     * 使用 Lock 手动加锁和释放锁。
     */
    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + " 卖出第 " + tickets + " 张票");
                    tickets--;
                } else {
                    break;
                }
            } finally {
                // 释放锁必须写在 finally 中，避免异常导致锁无法释放
                lock.unlock();
            }
        }
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorsDemo {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(3);

        for (int i = 1; i <= 5; i++) {
            int taskId = i;
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 执行任务 " + taskId);
            });
        }

        // shutdown 表示不再接收新任务，但会把已提交的任务执行完
        pool.shutdown();
    }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CustomThreadPoolDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                2,                              // 核心线程数：长期保留的线程数量
                4,                              // 最大线程数：任务高峰时最多能创建的线程数量
                60,                             // 非核心线程空闲后的存活时间
                TimeUnit.SECONDS,               // 存活时间单位
                new ArrayBlockingQueue<>(10),   // 任务队列：等待执行的任务存放位置
                new ThreadPoolExecutor.AbortPolicy() // 拒绝策略：任务太多时直接抛异常
        );

        for (int i = 1; i <= 20; i++) {
            int taskId = i;
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 执行任务 " + taskId);
            });
        }

        pool.shutdown();
    }
}

public class ThreadLocalDemo {
    // 定义一个 ThreadLocal 变量，用来存储字符串
    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        new Thread(() -> {
            threadLocal.set("线程A的数据");
            System.out.println(Thread.currentThread().getName() + " 获取数据：" + threadLocal.get());
            // 使用完记得移除，防止内存泄漏
            threadLocal.remove();
        }, "Thread-A").start();

        new Thread(() -> {
            threadLocal.set("线程B的数据");
            System.out.println(Thread.currentThread().getName() + " 获取数据：" + threadLocal.get());
            threadLocal.remove();
        }, "Thread-B").start();
    }
}