了解Java中的线程函数及其用法

Java是一种面向对象的编程语言，支持多线程和并发编程，线程是Java中最常用的并发编程机制之一。线程是一种轻量级的执行单元，它可以在同一个进程中同时执行多个任务。在Java中，线程是通过继承Thread类或实现Runnable接口来创建的。线程函数提供了一系列操作和管理线程的方法，下面我们来了解一下Java中的线程函数及其用法。

1. start()

start()方法是启动一个线程的方法，当调用线程对象的start()方法时，线程就开始执行。start()方法会调用线程的run()方法来执行线程代码。需要注意的是，start()方法只能启动一次，多次调用会抛出IllegalThreadStateException异常。下面是一个使用start()方法启动线程的示例代码：

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

2. run()

run()方法是线程的核心逻辑，当线程启动后，会自动调用run()方法。需要注意的是，如果直接调用run()方法，那么线程会在当前线程中执行，不会启动新的线程。下面是一个简单的示例代码：

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.run();  // 错误示例，不会启动新线程
    }
}

3. sleep()

sleep()方法是线程休眠的方法，可以暂停当前线程的执行一段时间。sleep()方法的单位是毫秒，需要注意的是，当线程处于休眠状态时，它不会释放锁。下面是一个使用sleep()方法暂停线程的示例代码：

public class MyThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread is running " + i);
            try {
                Thread.sleep(1000); // 暂停1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

4. join()

join()方法是使得调用线程等待被调用线程结束的方法。当调用线程对象的join()方法时，会暂停当前线程的执行，直到被调用线程执行完毕。下面是一个使用join()方法等待线程结束的示例代码：

public class MyThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread is running " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();
        thread.join();  // 等待线程执行完毕
        System.out.println("Main thread is running");
    }
}

5. interrupt()

interrupt()方法是中断线程的方法，可以用来请求线程停止执行。当调用线程对象的interrupt()方法时，线程会收到一个中断请求，如果线程正在阻塞状态，那么会立即抛出InterruptedException异常。需要注意的是，interrupt()方法只是发出中断请求，并不能直接停止线程的执行，线程可以通过判断中断状态来自行决定是否退出执行。下面是一个使用interrupt()方法中断线程的示例代码：

public class MyThread extends Thread {
    public void run() {
        try {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread is running " + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread is interrupted");
        }
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        thread.interrupt();  // 中断线程
    }
}

6. wait()

wait()方法是让线程等待的方法，可以暂停当前线程的执行，直到另一个线程调用notify()或notifyAll()方法通知它继续执行。wait()方法必须在synchronized块中调用，并且调用wait()方法会释放锁。下面是一个使用wait()方法暂停线程的示例代码：

public class MyThread {
    public synchronized void run() {
        System.out.println("Thread is running");
        try {
            wait();  // 等待被唤醒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread is resumed");
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        new Thread(() -> thread.run()).start();  // 启动子线程
        Thread.sleep(1000);  // 等待1秒
        synchronized (thread) {
            thread.notifyAll();  // 唤醒子线程
        }
    }
}

7. notify()和notifyAll()

notify()和notifyAll()方法是唤醒线程等待的方法，可以通知一个或多个等待的线程继续执行。notify()方法通知被wait()方法阻塞的线程中的一个线程继续执行，notifyAll()方法通知所有被wait()方法阻塞的线程继续执行。需要注意的是，notify()和notifyAll()方法必须在synchronized块中调用，且调用方法后并不会立即释放锁。下面是一个使用notify()和notifyAll()方法唤醒线程的示例代码：

public class MyThread {
    public synchronized void run() {
        System.out.println("Thread is running");
        try {
            wait();  // 等待被唤醒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread is resumed");
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        new Thread(() -> thread.run()).start();  // 启动子线程
        Thread.sleep(1000);  // 等待1秒
        synchronized (thread) {
            thread.notify();  // 唤醒子线程中的一个线程
            //thread.notifyAll();  // 唤醒子线程中的所有线程
        }
    }
}

总结：Java中提供了丰富的线程函数，用于操作和管理线程，掌握这些函数的用法可以帮助我们更好地编写并发程序，提高程序的并发性和效率。同时，在使用线程函数过程中，需要注意线程的状态和互斥锁的使用，保证线程的安全性和正确性。