Java中线程函数使用详解与应用举例

在Java中，线程是一种独立的执行路径，用于完成特定的任务。线程函数是线程的入口点，通过线程函数，可以定义线程要执行的代码。

Java中定义线程函数有两种方式：继承Thread类和实现Runnable接口。下面分别详细介绍这两种方式的使用方法。

1. 继承Thread类：

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

// 创建线程对象
MyThread thread = new MyThread();
// 启动线程
thread.start();

通过继承Thread类，我们可以重写run方法，在run方法中编写线程要执行的代码。创建线程对象后，调用start方法启动线程。

2. 实现Runnable接口：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程要执行的代码
    }
}

// 创建线程对象
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
// 启动线程
thread.start();

通过实现Runnable接口，我们可以将线程要执行的代码写在run方法中。创建线程对象时，将实现了Runnable接口的对象传入Thread的构造方法中，然后调用start方法启动线程。

在实际应用中，线程函数的使用是非常广泛的。下面举例说明几个常见的应用场景。

1. 多线程并发处理任务。

class Task implements Runnable {
    private String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name + " is running");
        // 执行任务的代码
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Task("Task1"));
        Thread thread2 = new Thread(new Task("Task2"));
        Thread thread3 = new Thread(new Task("Task3"));

        thread1.start();
        thread2.start();
        thread3.start();

        // 等待所有线程完成
        try {
            thread1.join();
            thread2.join();
            thread3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("All tasks completed");
    }
}

在这个例子中，我们创建了多个线程来并发处理任务。每个线程执行相同的任务，但任务的具体内容可以根据需要进行修改。通过使用join方法，我们可以确保在所有线程执行完成后再继续后续操作。

2. 生产者与消费者模型。

import java.util.LinkedList;
import java.util.Queue;

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

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

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            synchronized (queue) {
                while (queue.size() >= 5) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                queue.offer(i);
                queue.notifyAll();
            }
        }
    }
}

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 data = queue.poll();
                queue.notifyAll();
                System.out.println("Consumed: " + data);
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        Thread producerThread = new Thread(new Producer(queue));
        Thread consumerThread = new Thread(new Consumer(queue));

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

在这个例子中，我们模拟了生产者与消费者模型的情况。生产者线程负责向队列中生产数据，消费者线程负责从队列中消费数据。通过使用wait和notifyAll方法，我们可以实现生产者与消费者之间的同步。

以上就是Java中线程函数使用的详解与应用举例。通过合理使用线程函数，可以实现多线程并发处理任务、生产者与消费者模型等功能，提高程序的执行效率和性能。但需要注意线程安全问题，合理使用同步机制来避免并发冲突。