Java中多线程、三-CSDN博客

本文链接：https://blog.csdn.net/weixin_38862073/article/details/117392062

线程是程序中执行的线程，Java虚拟机允许应用程序同时运行多个执行线程。

一、线程池

*
* 线程池
*   背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
*   思路：提取创建好多个线程，放入线程池中，使用时直接获取，使用完放回线程池中，可以避免频繁创建、
*       销毁，实现重复利用。类似于生活中的公共交通工具
*   好处：
*       a: 提高相应速度（减少创建、销毁新线程的时间）
*           因为每个工作线程都可以被重复使用，可执行多个任务
*       b: 降低资源的消耗（重复利用线程池中的线程，不需要每次都创建）
*       c: 便于线程管理
*           可根据系统的承受能力，调整线程池中的线程数量，防止因为过多的消耗内存而导致服务器死机
*           每个线程需要大概1MB内存，线程开的越多，消耗内存越大
*   corePoolSize: 核心池的大小
*   maximumPoolSize: 最大线程数
*   keepAliveTime: 线程中没有任务是最多保持多长时间后会终止
*
* 线程池作用：
*   限制系统中执行线程的数量
*   根据系统的环境情况，可以自动或者手动来设置线程数量，已达到运行的最佳效果
*   线程少浪费系统资源，线程多造成系统拥挤效率不高
*   用线程池控制线程数量，其他线程排队等候
*   一个任务执行完成，再从队列中取最前面的任务开始执行
*   如果队列中没有等待线程，线程池的这个资源处于等待状态
*   当一个新任务需要运行时，如果此时线程中海油等待中的工作线程，可直接开始运行，否则需要进入等待队列
*
* 线程池API：ExecutorService 和 Executors
*   ExecutorService: 真正的线程池接口。常见子类ThreadPoolExecutor
*       void execute(Runnable command): 执行任务/命令，没有返回值，一般用来执行Runnable
*       <T>Future<T>submit(Callable<T> task): 执行任务，一般用来执行Callable
*       void shutdown(): 关闭线程池
*   Executors: 工具类，线程池的工厂类，用于创建并返回不同类型的线程池
*       Executors.newCachedThreadPool(): 创建一个可根据需要创建新线程的线程池
*       Executors.newFixedThreadPool(): 创建一个可重用固定线程数的线程池
*       Executors.newSingleThreadPool(): 创建一个只有一个线程的线程池
*       Executors.newScheduledThreadPool(): 创建一个线程池，它可安排在给定延迟后运行命令或定期执行
* */

public class _01_NewCachedThreadPoolTest {

    public static void main(String[] args) {
        // 创建一个可缓存线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程
        // 若没有可以回收的线程，则新建线程，线程池规模不限制，数量不固定

        // 创建池子
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            // 执行任务，传入Runnable的匿名内部类，也可以是实现类对象
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        System.out.println("-------------");
        // 关闭线程池
        cachedThreadPool.shutdown();
    }
}

/*
* 创建一个可重用固定线程数的线程池，可控制线程最大并发数
*   超出此数量的线程，会在队列中等待
* */
public class _02_NewFixedThreadPoolTest {

    public static void main(String[] args) {
        // 创建池子，指定最高并发3个
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        // 循环执行12个线程
        for (int i = 0; i < 12; i++) {
            // 执行任务，传入Runnable的匿名内部类，也可以是实现类对象
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        // 关闭线程池
        fixedThreadPool.shutdown();
    }
}

/*
* 创建一个线程池，它可安排在给定延迟后运行命令或定期执行
*   固定长度，支持定时周期性执行任务
* */
public class _03_NewScheduledThreadPoolTest {

    public static void main(String[] args) {
        test1();
//        test2();
    }

    public static void test1(){
        // 创建线程池，指定数量为5
        ScheduledExecutorService scheduledExecutorService =
                Executors.newScheduledThreadPool(5);

        for (int i = 0; i < 10; i++) {
            // 执行
            // schedule()参数：1 执行的任务 2 延迟时间 3 延迟时间单位
            scheduledExecutorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"延迟3秒后执行");
                }
            },3, TimeUnit.SECONDS);
        }

        // 关闭线程池
        scheduledExecutorService.shutdown();
    }

    /**
     * 延迟并间隔执行(相当于定时器)
     */
    public static void test2(){
        // 创建线程池，指定数量为5
        ScheduledExecutorService scheduledExecutorService =
                Executors.newScheduledThreadPool(5);

        // 执行，在初始延迟后 按时间间隔循环执行
        // schedule()参数：1 执行的任务。 2 延迟时间。 3 时间间隔。 4 延迟时间单位。
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟4秒后执行，且每1秒执行一次");
            }
        },4, 1, TimeUnit.SECONDS);

        // 关闭线程池
        // 此处不能关闭线程池，因为需要间隔执行，关闭池子就无法间隔执行
        // scheduledExecutorService.shutdown();
    }
}

*
* 创建一个只有一个线程的线程池，单线程线程池
*   如果这个线程因为异常结束，那么会有一个其他的线程来代替
*   该线程保证所有任务执行顺序是 按照任务提交顺序执行，谁先来谁先执行
*   适用于挨个任务执行的情况
* */
public class _04_NewSingleThreadExecutorTest {

    public static void main(String[] args) {
        // 创线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        // 一次创建10个请求，循环依次创建的线程依次执行，依次执行一个线程
        for (int i = 0; i < 10; i++) {
            System.out.println("创建 " + i + "次");
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName()+ ": " + index);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        // 关闭线程池
        singleThreadExecutor.shutdown();
    }
}

二、模拟实现3个窗口同时卖票

/*
* 模拟实现3个窗口同时卖票。票不重复。（线程同步）
* */
public class Thread_Ticket {

    public static void main(String[] args) {
        Sale sale = new Sale(100);
        Processor t1 = new Processor(sale);
        Processor t2 = new Processor(sale);
        Processor t3 = new Processor(sale);
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        Thread thread3 = new Thread(t3);
        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Processor implements Runnable{
    // true没卖完。false卖完
    static boolean flag = true;
    // 业务类
    Sale sale;

    public Processor(Sale sale) {
        this.sale = sale;
    }

    @Override
    public void run() {
        while (flag){
            sale.sellTicket();
        }
    }
}

// 业务类
class Sale{

    int ticket = 100;
    public Sale(int ticket) {
        this.ticket = ticket;
    }

    public synchronized void sellTicket(){

        // 不管是否卖完，都得唤醒另一个线程。否则wait之后不会自动醒
        this.notifyAll();

        if (ticket>0){
            System.out.println(Thread.currentThread().getName() + "卖出了" + ticket);
            ticket--;
        } else {
            System.out.println("票卖完了");
            // 把其他线程唤醒，否则wait之后不会自动醒
            this.notifyAll();
            // 卖完了标记为false
            Processor.flag = false;
            // 终止函数运行
            return;
        }

        try {
            // 睡眠一会儿 使得打印效果直观
            Thread.sleep(10);
            // 卖后就挂起
            this.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}