如何使用Java中的Thread创建和启动多线程程序?

在Java中，使用Thread类来创建和启动多线程程序。Thread类是一个内置类，提供了一组方法，用于控制和管理线程。多线程程序可以同时执行多个功能，提高系统的效率和性能。

1. 创建多线程

Java中创建多线程可以有两种方式：继承Thread类和实现Runnable接口。继承Thread类需要重写run()方法，实现Runnable接口需要实现run()方法。

a. 继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        //线程执行的逻辑
    }
}

//创建和启动线程
MyThread myThread = new MyThread();
myThread.start();

b. 实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        //线程执行的逻辑
    }
}

//创建和启动线程
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

2. 启动多线程

启动多线程的方式有两种：调用start()方法和run()方法。调用start()方法会创建新的线程执行run()方法，而直接调用run()方法会在当前线程中执行run()方法。

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程开始执行");
    }
}

//创建和启动线程
MyThread myThread = new MyThread();
myThread.start(); //调用start方法
myThread.run(); //调用run方法

3. 线程的状态

线程有不同的状态，在不同的状态下线程可以进行不同的操作。Java提供了一些方法来获取线程的状态。

a. 新建状态（New）：在创建线程对象后，线程处于新建状态，还没有开始执行。

b. 就绪状态（Runnable）：调用start()方法后，线程进入就绪状态，可以被JVM调度执行。

c. 运行状态（Running）：线程进入运行状态，执行run()方法。

d. 阻塞状态（Blocked）：线程进入阻塞状态，等待一些条件满足（如等待输入输出）。

e. 等待状态（Waiting）：线程进入等待状态，等待其他线程通知或中断。

f. 完成状态（Terminated）：线程执行完成后进入完成状态。

public class ThreadStateDemo {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("线程运行状态");
        });
        System.out.println("线程新建状态");
        System.out.println("线程状态：" + t.getState());
        t.start();
        System.out.println("线程就绪状态");
        System.out.println("线程状态：" + t.getState());
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程运行状态");
        System.out.println("线程状态：" + t.getState());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程完成状态");
        System.out.println("线程状态：" + t.getState());
    }
}

4. 线程的常用方法

a. join()方法：等待线程执行完成再执行下面的逻辑。

Thread t = new Thread(() -> {
    System.out.println("线程运行状态");
});
t.start();
try {
    t.join(); //等待线程执行完成
} catch (InterruptedException e) {
    e.printStackTrace();
}
System.out.println("主线程继续执行");

b. sleep()方法：使当前线程休眠一段时间。

Thread t = new Thread(() -> {
    try {
        Thread.sleep(1000); //线程休眠1秒
        System.out.println("线程运行状态");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
t.start();
try {
    Thread.sleep(2000); //主线程休眠2秒
} catch (InterruptedException e) {
    e.printStackTrace();
}
System.out.println("主线程继续执行");

c. interrupt()方法：中断线程的执行，抛出InterruptedException异常。

Thread t = new Thread(() -> {
    while (true) {
        if (Thread.currentThread().isInterrupted()) { //检测线程是否被中断
            System.out.println("线程中断");
            break;
        }
        System.out.println("线程运行状态");
    }
});
t.start();
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
System.out.println("主线程中断线程");
t.interrupt(); //中断线程

d. setPriority()方法：设置线程的优先级。

Thread t1 = new Thread(() -> {
    System.out.println("线程A优先级：" + Thread.currentThread().getPriority());
});
t1.setPriority(Thread.MIN_PRIORITY); //设置优先级为最低
t1.start();

Thread t2 = new Thread(() -> {
    System.out.println("线程B优先级：" + Thread.currentThread().getPriority());
});
t2.setPriority(Thread.MAX_PRIORITY); //设置优先级为最高
t2.start();

e. yield()方法：让出CPU执行权。

Thread t1 = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        System.out.println("线程A执行");
        Thread.yield(); //线程A让出CPU执行权
    }
});
t1.start();

Thread t2 = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        System.out.println("线程B执行");
        Thread.yield(); //线程B让出CPU执行权
    }
});
t2.start();

f. wait()方法和notify()方法：线程间的通信。

public class ThreadCommunicationDemo {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("线程A等待");
                    lock.wait(); //线程A等待通知
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程A收到通知");
            }
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程B通知");
                lock.notify(); //线程B发送通知
            }
        });
        t2.start();
    }
}

以上是Java中使用Thread类创建和启动多线程的基本方法和常用操作，利用多线程可以提高资源利用率，增加程序执行效率。同时需要注意线程同步和线程安全，避免出现线程安全问题导致程序异常或崩溃。