Java多线程、线程安全、线程池创建方式

// 1. 自定义线程类，继承Thread
public class MyThread extends Thread {
    // 2. 重写run()方法，线程执行的逻辑写在这里
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            // Thread.currentThread().getName() 获取当前线程名
            System.out.println(Thread.currentThread().getName() + "：执行了" + i);
        }
    }
    public static void main(String[] args) {
        // 3. 创建线程对象，设置线程名
        MyThread t1 = new MyThread();
        t1.setName("线程1");
        MyThread t2 = new MyThread();
        t2.setName("线程2");
        // 4. 启动线程：调用start()
        t1.start();
        t2.start();
        // 主线程也执行逻辑，对比看多线程效果
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程：执行了" + i);
        }
    }
}

// 1. 自定义任务类，实现Runnable接口
public class MyRunnable implements Runnable {
    // 2. 重写run()方法，编写任务逻辑
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "：执行了" + i);
        }
    }
    public static void main(String[] args) {
        // 3. 创建任务对象
        MyRunnable task = new MyRunnable();
        // 4. 把任务传给Thread，创建线程对象
        Thread t1 = new Thread(task, "线程1");
        Thread t2 = new Thread(task, "线程2");
        // 5. 启动线程
        t1.start();
        t2.start();
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
// 1. 自定义任务类，实现Callable接口，指定泛型为返回值类型（Integer）
public class MyCallable implements Callable<Integer> {
    // 2. 重写call()方法，有返回值，可抛异常
    @Override
    public Integer call() throws Exception {
        // 模拟计算：1-5的和
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
            System.out.println(Thread.currentThread().getName() + "：计算中，i=" + i);
        }
        return sum; // 返回计算结果
    }
    public static void main(String[] args) throws Exception {
        // 3. 创建Callable任务对象
        MyCallable callable = new MyCallable();
        // 4. 用FutureTask封装任务，用于获取返回值
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        // 5. 把FutureTask传给Thread，创建线程并启动
        Thread t = new Thread(futureTask, "计算线程");
        t.start();
        // 6. 获取线程执行结果：get()方法会阻塞，直到线程执行完成
        Integer result = futureTask.get();
        System.out.println(t.getName() + "执行结果：1-5的和=" + result);
    }
}

public class ThreadMethodDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(1000); // 休眠1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "：执行" + i);
            }
        }, "休眠线程");
        t.start();
        t.join(); // 主线程等待t执行完再执行
        System.out.println("主线程：执行完成，休眠线程已结束");
    }
}

// 售票任务类，实现Runnable
public class TicketRunnable implements Runnable {
    // 共享资源：10张票（多个线程共用这个变量）
    private int ticketNum = 10;
    @Override
    public void run() {
        // 循环卖票
        while (true) {
            // 有票就卖
            if (ticketNum > 0) {
                try {
                    Thread.sleep(500); // 模拟选座、打印票的耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖出了1张票，剩余：" + --ticketNum);
            } else {
                // 无票就退出
                break;
            }
        }
    }
    public static void main(String[] args) {
        // 一个任务对象，3个线程共享
        TicketRunnable task = new TicketRunnable();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

synchronized(锁对象) {
    // 操作共享资源的代码块（临界区）
}

public class TicketSyncBlock implements Runnable {
    private int ticketNum = 10;
    // 锁对象：多个线程共用同一个
    private Object lock = new Object();
    @Override
    public void run() {
        while (true) {
            // 同步代码块：加锁，操作共享资源的代码排队执行
            synchronized (lock) {
                if (ticketNum > 0) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出了1张票，剩余：" + --ticketNum);
                } else {
                    break;
                }
            }
        }
    }
    public static void main(String[] args) {
        TicketSyncBlock task = new TicketSyncBlock();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

public class TicketSyncMethod implements Runnable {
    private int ticketNum = 10;
    @Override
    public void run() {
        while (true) {
            // 调用同步方法
            if (!sellTicket()) {
                break;
            }
        }
    }
    // 同步方法：synchronized修饰，操作共享资源的代码
    private synchronized boolean sellTicket() {
        if (ticketNum > 0) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖出了1张票，剩余：" + --ticketNum);
            return true;
        } else {
            return false;
        }
    }
    public static void main(String[] args) {
        TicketSyncMethod task = new TicketSyncMethod();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

import java.util.concurrent.locks.ReentrantLock;
public class TicketLock implements Runnable {
    private int ticketNum = 10;
    // 创建Lock锁对象，可重入锁
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            // 手动加锁
            lock.lock();
            try {
                // 操作共享资源的代码
                if (ticketNum > 0) {
                    Thread.sleep(500);
                    System.out.println(Thread.currentThread().getName() + "卖出了1张票，剩余：" + --ticketNum);
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 手动释放锁，放在finally中，保证一定执行
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) {
        TicketLock task = new TicketLock();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolRunnable {
    public static void main(String[] args) {
        // 1. 创建固定线程池：核心线程数为2
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //使用线程池的实现类ThreadPoolExecutor创建线程池对象。（有七个参数）
        //ExecutorService pool = new ThreadPoolExecutor(
        //        2,//核心线程数
        //        2,//最大线程数
        //        0,//线程空闲时间
        //        TimeUnit.SECONDS,//时间单位
        //        new ArrayBlockingQueue<>(2),//任务队列
        //        Executors.defaultThreadFactory(),//线程工厂对象
        //        new ThreadPoolExecutor.AbortPolicy()//拒绝策略
        //);
        // 2. 提交Runnable任务给线程池
        pool.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    System.out.println(Thread.currentThread().getName() + "执行Runnable任务：" + i);
                }
            }
        });
        pool.submit(() -> { // Lambda简化Runnable
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "执行Lambda任务：" + i);
            }
        });
        // 3. 关闭线程池：shutdown()等待任务执行完再关闭，shutdownNow()立即关闭
        pool.shutdown();
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadPoolCallable {
    public static void main(String[] args) throws Exception {
        // 1. 创建固定线程池，核心线程数1
        ExecutorService pool = Executors.newFixedThreadPool(1);
        // 2. 提交Callable任务，Future接收返回值
        Future<Integer> future = pool.submit(() -> {
            // 计算1-10的和
            int sum = 0;
            for (int i = 1; i <= 10; i++) {
                sum += i;
            }
            return sum;
        });
        // 3. 获取返回值
        Integer result = future.get();
        System.out.println("Callable任务执行结果：1-10的和=" + result);
        // 4. 关闭线程池
        pool.shutdown();
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledThreadPoolDemo {
    public static void main(String[] args) {
        // 创建定时线程池，核心线程数2
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
        // 1. 延迟执行：延迟1秒后执行一次任务
        pool.schedule(() -> {
            System.out.println(Thread.currentThread().getName() + "：延迟1秒执行");
        }, 1, TimeUnit.SECONDS);
        // 2. 定时执行：延迟2秒后，每3秒执行一次任务
        pool.scheduleAtFixedRate(() -> {
            System.out.println(Thread.currentThread().getName() + "：定时执行，每3秒一次");
        }, 2, 3, TimeUnit.SECONDS);
    }
}