java简单实现多线程及线程池实例详解

关于 "java简单实现多线程及线程池实例详解" 的攻略，下面是完整的讲解，分为以下几个部分：

1. 多线程的基本概念

1.1 什么是多线程

多线程，就是在一个程序中有多个线程同时执行，每个线程拥有自己的栈、局部变量等，但是共享同一进程的内存空间和全局变量。

1.2 多线程的优点

多线程可以提高程序的并发性，改善用户体验。同时，多线程还可以充分利用多核 CPU 的优势，提高程序的执行效率。

2. Java 实现多线程的方法

2.1 继承 Thread 类

继承 Thread 类是最基本的实现多线程的方法，在 Java 中，每个线程都是通过 Thread 类的对象实现的。

class MyThread extends Thread {
    public void run(){
        // 这里是线程执行的代码
    }
}

2.2 实现 Runnable 接口

Java 中还有另外一种实现多线程的方法，就是实现 Runnable 接口。

class MyRunnable implements Runnable{
    public void run() {
        // 这里是线程执行的代码
    }
}

2.3 创建线程并启动线程

在 Java 中启动线程是通过调用 start() 方法来实现的，当 start() 方法被调用时，线程会进入就绪状态，等待 CPU 调度，并开始执行线程的 run() 方法。

MyThread thread = new MyThread();
thread.start();

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

3. 线程池的概念

3.1 什么是线程池

线程池就是预先创建一定数量的线程，这些线程统一由线程池管理，任务到来时，线程池中的线程会自动分配任务并执行。

3.2 线程池的优点

线程池可以避免线程的过度创建和销毁，减少系统资源的浪费，以及提高了代码的可维护性。

3.3 线程池的组成

线程池由三部分组成：工作队列、线程池管理器、线程池。

4. Java 实现线程池的方法

4.1 创建一个线程池

ThreadPoolExecutor pool = 
    new ThreadPoolExecutor(
        nThreads, // 核心线程数
        maxThreads, // 最大线程数
        keepAliveTime, // 非核心线程数的存活时间
        TimeUnit.MILLISECONDS, // 存活时间单位
        new LinkedBlockingQueue<Runnable>(), // 工作队列
        Executors.defaultThreadFactory(), // 线程工厂
        new ThreadPoolExecutor.AbortPolicy()); // 拒绝策略

4.2 向线程池提交任务

pool.execute(new MyRunnable());

4.3 关闭线程池

pool.shutdown();

5. 示例说明

5.1 实现多线程计算累加和

class MyThread extends Thread {
    private int sum = 0;

    public int getSum() {
        return sum;
    }

    public void run(){
        for(int i=1;i<=100;i++){
            sum += i;
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        int sum = t1.getSum() + t2.getSum();
        System.out.println("sum = " + sum);
    }
}

5.2 实现线程池下载图片

public class Main {
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                4,  // 核心线程数为4
                8,  // 最大线程数为8
                5,  // 非核心线程的存活时间为5毫秒
                TimeUnit.MILLISECONDS, // 存活时间的时间单位为毫秒
                new LinkedBlockingQueue<Runnable>(), // 设置任务队列为LinkedBlockingQueue
                Executors.defaultThreadFactory(), // 设置线程工厂
                new ThreadPoolExecutor.AbortPolicy()); // 设置拒绝策略

        String[] urls = {
                "https://www.baidu.com/img/flexible/logo/pc/result.png",
                "https://www.baidu.com/img/flexible/logo/pc/result.png",
                "https://www.baidu.com/img/flexible/logo/pc/result.png",
                "https://www.baidu.com/img/flexible/logo/pc/result.png",
                "https://www.baidu.com/img/flexible/logo/pc/result.png",
                "https://www.baidu.com/img/flexible/logo/pc/result.png",
                "https://www.baidu.com/img/flexible/logo/pc/result.png",
                "https://www.baidu.com/img/flexible/logo/pc/result.png"
        };

        for (String url : urls) {
            pool.execute(() -> {
                downloadImage(url);
            });
        }

        pool.shutdown();
    }

    private static void downloadImage(String url) {
        try {
            URL u = new URL(url);
            HttpURLConnection conn = (HttpURLConnection) u.openConnection();
            InputStream stream = conn.getInputStream();
            File file = new File("image_" + System.currentTimeMillis() + ".png");
            FileOutputStream fos = new FileOutputStream(file);
            byte[] buffer = new byte[1024];
            int len = -1;
            while ((len = stream.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
            fos.flush();
            fos.close();
            stream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}