如何使用多线程
在Java中，创建多线程的方式有两种：一种是继承Thread类，另一种是实现Runnable接口。以下是两种方式的详细介绍和代码示例：
继承Thread类
创建一个多线程，可以继承Thread类并重写它的run()方法。run()方法是线程的主体，当线程启动后，它的run()方法会被调用，并且该方法的执行过程中，线程将处于“运行”状态。
下面是一个简单的继承Thread类的多线程示例：
public class MyThread extends Thread { public void run() { // 线程的主体，可以在这里编写需要执行的代码 } }
使用这个类创建一个新线程非常简单，只需要实例化该类并调用它的start()方法即可。start()方法会启动线程并调用run()方法。
MyThread myThread = new MyThread(); myThread.start();
实现Runnable接口
Java中还提供了一种创建多线程的方式，即实现Runnable接口。实现Runnable接口的类需要实现run()方法，该方法的代码将被线程执行。
下面是一个实现Runnable接口的多线程示例：
public class MyRunnable implements Runnable { public void run() { // 线程的主体，可以在这里编写需要执行的代码 } }
使用这个类创建一个新线程的方式和继承Thread类的方式类似，只需要实例化该类并将它作为参数传递给Thread的构造方法即可。
MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); thread.start();
线程的生命周期
线程的生命周期指的是线程从创建到销毁的整个过程。Java线程的生命周期可以分为以下5个阶段：
新建状态（New）：当一个线程被创建时，它处于新建状态。此时线程还没有开始执行，也还没有分配到系统资源。
就绪状态（Runnable）：当线程调用start()方法后，线程处于就绪状态。此时线程已经分配到了系统资源，等待系统调度它的时候开始执行。
运行状态（Running）：当线程被系统调度执行时，线程处于运行状态。此时线程正在执行run()方法中的代码。
阻塞状态（Blocked）：线程在执行过程中，可能会因为某些原因需要暂停执行，此时线程处于阻塞状态。比如，线程被sleep()、wait()、join()等方法调用时，线程将进入阻塞状态。
终止状态（Terminated）：线程执行完了run()方法中的代码，或者因为异常而中断了线程，此时线程将进入终止状态。终止状态的线程不再执行任何代码。
下面是一个简单的演示线程生命周期的示例：
public class MyThread extends Thread { public void run() { System.out.println("线程处于新建状态"); try { Thread.sleep(1000); System.out.println("线程处于就绪状态"); Thread.sleep(1000); System.out.println("线程处于运行状态"); Thread.sleep(1000); System.out.println("线程处于阻塞状态"); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }
在这个示例中，线程将会依次进入新建状态、就绪状态、运行状态和阻塞状态。运行这个线程的代码如下：
MyThread myThread = new MyThread(); myThread.start();
线程同步
在多线程程序中，由于多个线程共享同一份资源，可能会发生冲突问题，比如多个线程同时对同一变量进行写操作，这时就需要使用同步机制来保证线程安全。
Java提供了两种同步机制：synchronized关键字和Lock接口。synchronized关键字是Java中最常用的同步机制，它可以用来修饰方法或代码块。当一个方法或代码块被synchronized修饰后，只有一个线程能够执行该方法或代码块。
下面是一个使用synchronized关键字实现线程同步的示例：
public class MyThread implements Runnable { private int count = 0; public synchronized void increase() { count++; } public void run() { for (int i = 0; i < 100000; i++) { increase(); } } }
在这个示例中，increase()方法被synchronized关键字修饰，当一个线程执行increase()方法时，其他线程必须等待，直到当前线程执行完毕才能执行该方法。
下面是一个使用Lock接口实现线程同步的示例：
public class MyThread implements Runnable { private int count = 0; private Lock lock = new ReentrantLock(); public void increase() { lock.lock(); try { count++; } finally { lock.unlock(); } } public void run() { for (int i = 0; i < 100000; i++) { increase(); } } }
在这个示例中，increase()方法使用了Lock接口来实现线程同步，当一个线程获取了锁后，其他线程必须等待，直到当前线程释放锁才能获取锁执行该方法。
线程间通信
多个线程之间需要进行通信时，可以使用wait()、notify()和notifyAll()方法来实现。
wait()方法会使当前线程进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒该线程。notify()方法会随机唤醒一个处于等待状态的线程，而notifyAll()方法会唤醒所有处于等待状态的线程。
下面是一个使用wait()和notify()方法实现线程间通信的示例：
public class MyThread implements Runnable { private boolean ready = false; public synchronized void waitForReady() throws InterruptedException { while (!ready) { wait(); } } public synchronized void setReady() { ready = true; notify(); } public void run() { try { waitForReady(); System.out.println("Thread is ready."); } catch (InterruptedException e) { e.printStackTrace(); } } }
在这个示例中，waitForReady()方法会使当前线程进入等待状态，直到其他线程调用setReady()方法将ready标志设置为true并调用notify()方法唤醒该线程。
运行这个线程的代码如下：
MyThread myThread = new MyThread(); new Thread(myThread).start(); Thread.sleep(1000); myThread.setReady();
在这个代码中，启动了一个线程并休眠1秒钟，然后调用setReady()方法将ready标志设置为true并调用notify()方法唤醒该线程。
线程池
线程池是一种重用线程的机制，它可以避免线程的频繁创建和销毁，提高了线程的利用率和效率。
Java提供了Executor框架来实现线程池。Executor框架提供了一些接口，如Executor、ExecutorService、ScheduledExecutorService等，可以用来创建线程池。
下面是一个使用Executor框架实现线程池的示例：
public class MyThread implements Runnable { private int taskId; public MyThread(int taskId) { this.taskId = taskId; } public void run() { System.out.println("Task " + taskId + " is running."); } public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(3); for (int i = 1; i <= 10; i++) { executorService.submit(new MyThread(i)); } executorService.shutdown(); } }
在这个示例中，创建了一个包含3个线程的线程池，然后提交了10个任务给线程池执行。最后调用shutdown()方法关闭线程池。
