Java多线程函数的使用说明和实例演示
Java多线程是Java语言中一个非常重要的特性，这使得开发人员可以在一个应用程序或者系统中同时运行多个任务。多线程程序可以更加高效地利用计算机资源，提高程序的响应速度和并发性能。
在Java中，创建多线程程序非常简单，只需要继承Thread类并重写run()方法或者实现Runnable接口并实现run()方法，然后调用start()方法启动线程即可。下面介绍一些常用的多线程函数。
1. sleep()函数
sleep()函数是线程类中的一个静态方法，调用该方法可以使当前线程暂停执行指定的毫秒数。这个方法主要用于控制线程的执行时间，可以让线程在执行一段时间后休眠一段时间，以免过多占用CPU资源。
例如，实现一个定时器程序：
public class TimerThread extends Thread{
public void run(){
try{
for(int i=0;i<10;i++){
System.out.println("当前时间："+new Date());
//线程休眠一秒
Thread.sleep(1000);
}
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
然后在主函数中调用该线程：
public class Main{
public static void main(String[] args){
TimerThread t=new TimerThread();
t.start();
}
}
这个程序会输出当前时间，并且每隔1秒钟输出一次。
2. join()函数
join()函数是Thread类中的一个方法，调用该方法可以使当前线程等待另一个线程执行完毕后再继续执行。这个方法主要用于控制线程的执行顺序，可以让一个线程在另一个线程完成任务后再执行，以实现线程之间的同步。
例如，实现一个简单的线程同步程序：
public class SyncThread extends Thread{
public void run(){
for(int i=0;i<10;i++){
System.out.println("线程："+Thread.currentThread().getName()+"，输出："+i);
}
}
}
public class Main{
public static void main(String[] args) throws InterruptedException{
SyncThread t1=new SyncThread();
SyncThread t2=new SyncThread();
SyncThread t3=new SyncThread();
t1.start();
//等待t1线程执行完毕
t1.join();
t2.start();
//等待t2线程执行完毕
t2.join();
t3.start();
}
}
这个程序会创建3个线程，每个线程输出1-9的数字，在执行前需要等待前面的线程执行完毕后才能继续执行。输出结果如下：
线程：Thread-0，输出：0 线程：Thread-0，输出：1 线程：Thread-0，输出：2 线程：Thread-0，输出：3 线程：Thread-0，输出：4 线程：Thread-0，输出：5 线程：Thread-0，输出：6 线程：Thread-0，输出：7 线程：Thread-0，输出：8 线程：Thread-1，输出：0 线程：Thread-1，输出：1 线程：Thread-1，输出：2 线程：Thread-1，输出：3 线程：Thread-1，输出：4 线程：Thread-1，输出：5 线程：Thread-1，输出：6 线程：Thread-1，输出：7 线程：Thread-1，输出：8 线程：Thread-2，输出：0 线程：Thread-2，输出：1 线程：Thread-2，输出：2 线程：Thread-2，输出：3 线程：Thread-2，输出：4 线程：Thread-2，输出：5 线程：Thread-2，输出：6 线程：Thread-2，输出：7 线程：Thread-2，输出：8
3. yield()函数
yield()函数是Thread类中的一个静态方法，调用该方法可以使当前线程放弃CPU资源，使其他线程有机会运行。这个方法主要用于控制线程的执行顺序，可以让CPU更加公平地分配执行时间，提高程序的并发性能。
例如，实现一个简单的线程调度程序：
public class ScheduleThread extends Thread{
private int id;
private static int count;
public ScheduleThread(){
this.id=++count;
}
public void run(){
for(int i=0;i<10;i++){
System.out.println("线程："+id+"，输出："+i);
//线程放弃CPU资源
Thread.yield();
}
}
}
public class Main{
public static void main(String[] args){
ScheduleThread t1=new ScheduleThread();
ScheduleThread t2=new ScheduleThread();
ScheduleThread t3=new ScheduleThread();
t1.start();
t2.start();
t3.start();
}
}
这个程序会创建3个线程，每个线程输出1-9的数字，并且在输出前调用yield()方法放弃CPU资源。输出结果不一定按照线程顺序，可能会产生一些交替输出的效果。
4. interrupt()函数
interrupt()函数是Thread类中的一个方法，调用该方法可以中断一个线程的执行，并且抛出InterruptedException异常。这个方法主要用于控制线程的执行状态，可以让一个线程在外部条件满足时及时中断执行。
例如，实现一个简单的线程中断程序：
public class InterruptThread extends Thread{
public void run(){
while(true){
if(Thread.interrupted()){
System.out.println("线程已中断。");
break;
}
System.out.println("线程正在执行。");
}
}
}
public class Main{
public static void main(String[] args) throws InterruptedException{
InterruptThread t=new InterruptThread();
t.start();
//休眠一秒后中断t线程
Thread.sleep(1000);
t.interrupt();
}
}
这个程序创建一个线程，然后在执行一段时间后中断线程，并且输出提示信息。输出结果如下：
线程正在执行。 线程正在执行。 线程正在执行。 线程正在执行。 线程正在执行。 线程正在执行。 线程正在执行。 线程正在执行。 线程正在执行。 线程正在执行。 线程正在执行。 线程正在执行。 线程正在执行。 线程已中断。
5. wait()和notify()函数
wait()和notify()函数是Object类中的方法，任何Java对象都可以调用这两个方法。wait()方法可以使当前线程等待另一个线程的通知，notify()方法可以通知等待的线程继续执行。这两个方法主要用于控制线程的同步，可以让一个线程等待另一个线程的结果进行下一步操作。
例如，实现一个简单的生产者和消费者程序：
`
public class ProducerConsumer{
private int count;
public synchronized void produce(){
while(count>=10){
try{
System.out.println("仓库已满。");
//等待消费者通知
wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
count++;
System.out.println("生产者生产了1件商品，当前仓库数量："+count);
//通知消费者可以购买
notify();
}
public synchronized void consume(){
while(count<=0){
try{
System.out.println("仓库已空。");
//等待生产者通知
wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
count--;
System.out.println("消费者购买了1件商品，当前仓库数量："+count);
//通知生产者可以生产
notify();
}
}
public class ProducerThread extends Thread{
private ProducerConsumer pc;
public ProducerThread(ProducerConsumer pc){
this.pc=pc;
}
public void run(){
for(int i=0;i<10;i++){