Java多线程编程入门指南

Java多线程编程是Java编程语言的核心之一，它提供了一种并发执行代码的方式，允许多个任务同时运行。本文将向您介绍Java多线程编程入门指南，为您了解多线程编程提供基础知识和实践方法。

一、多线程背景

随着计算机的发展，我们需要开发更加复杂的应用程序，以满足日益增长的需求。开发比单线程运行时间更快的程序是其中的一个重要挑战。那么，我们如何提高程序的执行速度呢？

在Java中，我们可以通过多线程编程实现并行执行。与单线程程序相比，多线程程序可以利用计算机的多个处理器实现任务并行。

二、多线程编程入门

1. 创建线程的方法

在Java多线程编程中，我们可以通过以下两种方式来创建线程：

1.1 继承Thread类

继承Thread类并重写run()方法，然后创建Thread对象，最后调用start()方法启动线程。

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

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();   //创建线程对象
        myThread.start();   //调用start()方法启动线程
    }
}

1.2 实现Runnable接口

实现Runnable接口，并重写run()方法，然后创建Thread对象并传入Runnable实例，最后调用start()方法启动线程。

class MyThread implements Runnable {
    public void run() {
        //线程执行代码
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();   //创建Runnable实例
        Thread thread = new Thread(myThread);   //创建Thread对象并传入Runnable实例
        thread.start();   //调用start()方法启动线程
    }
}

2. 线程的状态

线程在Java中有以下几种状态：

2.1 新建状态（New）

创建线程对象时，线程处于新建状态，还没有启动。

2.2 运行状态（Runnable）

进入运行状态后，线程开始执行run()方法中的代码。

2.3 阻塞状态（Blocked）

当线程在等待某些条件（比如锁）时，线程将进入阻塞状态，暂时停止运行。

2.4 等待状态（Waiting）

当线程调用wait()方法或join()方法后，线程将进入等待状态，等待其他线程执行特定的操作。

2.5 计时等待状态（Timed Waiting）

当线程调用sleep()方法或带有超时参数的wait()方法后，线程将进入计时等待状态，等待一段时间后自动唤醒线程。

2.6 终止状态（Terminated）

线程执行完run()方法后，进入终止状态。

3. 线程同步

线程同步是指多个线程在访问共享资源时保证数据一致性的机制。在Java中，我们可以通过以下方法来同步线程：

3.1 同步方法

在方法前加上synchronized关键字，使得当前方法变为同步方法。同一时刻只有一个线程可以访问这个方法，其他线程必须等待。

class MyClass {
    public synchronized void myMethod() {   //同步方法
        //代码块
    }
}

3.2 同步代码块

在代码块前加上synchronized关键字，使得当前代码块变为同步代码块。同一时刻只有一个线程可以访问这个代码块，其他线程必须等待。

class MyClass {
    public void myMethod() {
        synchronized (this) {   //同步代码块
            //代码块
        }
    }
}

三、多线程编程实践

1. 多线程下载文件

以下示例展示了如何使用多线程下载文件：

import java.io.*;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class DownloadManager {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);    //创建线程池
        String[] urls = {"url1", "url2", "url3"};   //待下载文件的URL
        for (String url : urls) {
            executorService.submit(new DownloadTask(url));   //提交下载任务到线程池
        }
        executorService.shutdown();   //关闭线程池
    }
}

class DownloadTask implements Runnable {
    private String url;

    public DownloadTask(String url) {
        this.url = url;
    }

    @Override
    public void run() {
        try {
            URL url = new URL(this.url);
            InputStream inputStream = url.openStream();
            FileOutputStream fileOutputStream = new FileOutputStream(new File(this.url));
            byte[] buffer = new byte[1024 * 4];
            int length;
            while ((length = inputStream.read(buffer)) != -1) {
                fileOutputStream.write(buffer, 0, length);
            }
            inputStream.close();
            fileOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 多线程爬虫

以下示例展示了如何使用多线程实现爬虫：

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

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.select.Elements;

public class Crawler {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);    //创建线程池
        String url = "https://www.example.com";   //起始URL
        executorService.submit(new CrawlerTask(url));   //提交第一个爬虫任务到线程池
        executorService.shutdown();   //关闭线程池
    }
}

class CrawlerTask implements Runnable {
    private String url;

    public CrawlerTask(String url) {
        this.url = url;
    }

    @Override
    public void run() {
        try {
            Document doc = Jsoup.connect(url).get();    //获取HTML文档
            Elements links = doc.select("a[href]");   //获取所有链接
            for (org.jsoup.nodes.Element link : links) {
                String href = link.attr("abs:href");   //获取链接绝对路径
                if (href.startsWith("https://www.example.com")) {   //只抓取同一域名下的URL
                    CrawlerManager.getInstance().submit(href);   //将链接添加到爬虫管理器中
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class CrawlerManager {
    private static CrawlerManager instance = null;
    private ExecutorService executorService = null;

    private CrawlerManager() {
        executorService = Executors.newFixedThreadPool(3);   //创建线程池
    }

    public static synchronized CrawlerManager getInstance() {
        if (instance == null) {
            instance = new CrawlerManager();   //初始化实例
        }
        return instance;
    }

    public void submit(String url) {
        executorService.submit(new CrawlerTask(url));   //提交新的爬虫任务到线程池
    }

    public void shutdown() {
        executorService.shutdown();   //关闭线程池
    }
}