Java多线程应用实现方法

什么是多线程

多线程是指程序中同时存在多个线程执行不同的任务。在Java中，每个线程都是一个单独的执行流程，每个线程都拥有自己的栈空间和执行上下文。

为什么需要使用多线程

在某些场景下，使用多线程能够提高程序的运行效率和响应速度。举例来说，当一个程序需要从网络上下载文件时，若使用单线程实现，则下载完一个文件后才会开始下载下一个文件，这会非常浪费时间。但是，若采用多线程实现，则可以同时下载多个文件，从而提高下载速度。

Java多线程的实现方法

在Java中，实现多线程主要有两种方法：继承Thread类和实现Runnable接口。下面将分别进行介绍。

继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread " + Thread.currentThread().getId() + " is running.");    
    }
}

public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
        MyThread t = new MyThread();
        t.start();
    }
}

首先，创建一个继承Thread类的子类，并重写run方法。在run方法中实现线程要执行的逻辑。然后，在主线程中创建MyThread的实例，并调用start方法启动线程。

实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread " + Thread.currentThread().getId() + " is running.");    
    }
}

public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

创建一个实现Runnable接口的类，并实现run方法。在run方法中实现线程要执行的逻辑。然后，在主线程中创建Thread的实例，并将MyRunnable的实例作为参数传入。最后调用start方法启动线程。

示例说明

示例1：计算1到1000的和

public class SumThread extends Thread {
    private int start;
    private int end;
    private int sum;

    public SumThread(int start, int end) {
        this.start = start;
        this.end = end;
    }

    public int getResult() {
        return sum;
    }

    @Override
    public void run() {
        for (int i = start; i <= end; i++) {
            sum += i;
        }
    }
}

public static void main(String[] args) {
    SumThread t1 = new SumThread(1, 500);
    SumThread t2 = new SumThread(501, 1000);

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

    try {
        t1.join();
        t2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    int result = t1.getResult() + t2.getResult();
    System.out.println("1~1000的和为：" + result);
}

在这个示例中，我们创建了两个SumThread的实例，每个实例计算1到500或501到1000的和。通过并发执行这两个线程可以大大提高计算速度。在主线程中等待两个线程计算完成，并将结果相加得到最终的结果。

示例2：线程之间的协作-生产者消费者问题

public class Producer implements Runnable {
    private Queue<Integer> queue;
    private int maxSize;

    public Producer(Queue<Integer> queue, int maxSize) {
        this.queue = queue;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.size() == maxSize) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Random random = new Random();
                int n = random.nextInt(1000);
                System.out.println("Producer produces " + n);
                queue.offer(n);
                queue.notifyAll();
            }
        }
    }
}

public class Consumer implements Runnable {
    private Queue<Integer> queue;

    public Consumer(Queue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.isEmpty()) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int n = queue.poll();
                System.out.println("Consumer consumes " + n);
                queue.notifyAll();
            }
        }
    }
}

public static void main(String[] args) {
    Queue<Integer> queue = new LinkedList<>();

    Producer producer = new Producer(queue, 5);
    Consumer consumer = new Consumer(queue);

    Thread producerThread = new Thread(producer);
    Thread consumerThread = new Thread(consumer);

    producerThread.start();
    consumerThread.start();
}

在这个示例中，我们创建了两个类：Producer和Consumer，用于模拟生产者和消费者。Producer负责往队列中添加数据，Consumer负责从队列中取数据。两个线程之间需要协作，需要通过wait和notify方法来保证线程安全。在主线程中创建两个线程并启动。