5.1. 线程的创建与管理

在本节中，我们将详细讨论Java中的线程创建与管理，包括创建线程的方法、线程生命周期、线程优先级等。我们将通过实例来讲解每个知识点，确保你能够全面理解。

5.1.1 什么是线程？

线程是程序中的执行单元，是操作系统调度的基本单位。在Java中，多线程指的是在同一时间内，一个程序可以执行多个任务。多线程编程可以提高程序的执行效率，充分利用计算机资源。

5.1.2 创建线程的两种方法

在Java中，创建线程有两种方法：

1. 继承java.lang.Thread类
2. 实现java.lang.Runnable接口

5.1.2.1 继承Thread类

要使用继承Thread类的方法创建线程，我们需要：

1. 创建一个类，继承Thread类。
2. 重写run()方法，在该方法中编写具体的任务逻辑。
3. 实例化该类的对象，并调用start()方法启动线程。

示例：

// 创建一个类，继承Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        // 在run()方法中编写任务逻辑
        for (int i = 0; i < 5; i++) {
            System.out.println("MyThread: " + i);
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        // 实例化MyThread对象，并调用start()方法启动线程
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

5.1.2.2 实现Runnable接口

要使用实现Runnable接口的方法创建线程，我们需要：

1. 创建一个类，实现Runnable接口。
2. 重写run()方法，在该方法中编写具体的任务逻辑。
3. 实例化该类的对象，将对象作为参数传递给Thread类的构造方法。
4. 调用Thread对象的start()方法启动线程。

示例：

// 创建一个类，实现Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 在run()方法中编写任务逻辑
        for (int i = 0; i < 5; i++) {
            System.out.println("MyRunnable: " + i);
        }
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        // 实例化MyRunnable对象，将对象作为参数传递给Thread类的构造方法
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        // 调用Thread对象的start()方法启动线程
        thread.start();
    }
}

5.1.3 线程生命周期

线程有五种状态：

1. 新建（New）：线程对象被创建后，处于新建状态。
2. 就绪（Runnable）：当线程对象调用start()方法后，线程进入就绪状态。处于就绪状态的线程有可能正在运行，也有可能正在等待系统分配资源。
3. 运行（Running）：当线程获得系统资源，开始执行run()方法中的代码时，线程处于运行状态。
4. 阻塞（Blocked）：当线程因某种原因（如等待I/O操作完成、等待获取锁等）而暂时停止执行时，线程处于阻塞状态。
5. 死亡（Terminated）：当线程执行完run()方法中的代码或者因异常而终止时，线程处于死亡状态。

5.1.4 线程优先级

Java中的线程具有优先级，优先级高的线程有更大的机会获得执行。线程优先级的范围是1到10，其中1表示最低优先级，10表示最高优先级，5表示默认优先级。可以使用Thread类的setPriority(int newPriority)方法设置线程优先级，使用getPriority()方法获取线程优先级。

示例：

class PriorityThread extends Thread {
    public PriorityThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName() + ": " + i);
        }
    }
}

public class ThreadPriorityExample {
    public static void main(String[] args) {
        PriorityThread lowPriorityThread = new PriorityThread("LowPriority");
        PriorityThread highPriorityThread = new PriorityThread("HighPriority");

        // 设置线程优先级
        lowPriorityThread.setPriority(Thread.MIN_PRIORITY); // 最低优先级
        highPriorityThread.setPriority(Thread.MAX_PRIORITY); // 最高优先级

        lowPriorityThread.start();
        highPriorityThread.start();
    }
}

在上述示例中，我们创建了两个线程，一个具有最低优先级，另一个具有最高优先级。需要注意的是，线程优先级不能保证线程的执行顺序，它只是提高了线程获得执行的机会。

5.1.5 线程同步与互斥

在多线程环境下，多个线程可能会访问共享资源，这可能导致数据不一致的问题。为了解决这个问题，我们需要使用线程同步与互斥机制来确保同一时刻只有一个线程可以访问共享资源。

Java提供了synchronized关键字来实现线程同步。我们可以使用synchronized修饰方法或者在方法内部使用synchronized代码块。

示例：使用synchronized修饰方法

class Counter {
    private int count;

    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }

    public synchronized int getCount() {
        return count;
    }
}

示例：使用synchronized代码块

class Counter {
    private int count;

    public void increment() {
        synchronized (this) {
            count++;
        }
    }

    public void decrement() {
        synchronized (this) {
            count--;
        }
    }

    public int getCount() {
        synchronized (this) {
            return count;
        }
    }
}

5.1.6 小结

通过本节的学习，我们了解了Java中线程的基本概念、创建方法、生命周期、优先级以及同步与互斥。多线程编程是Java高级开发的重要内容，需要多加练习和深入理解。

请务必掌握以下重点：

1. 线程的概念及作用。
2. 创建线程的两种方法：继承Thread类和实现Runnable接口。
3. 线程生命周期的五种状态：新建、就绪、运行、阻塞、死亡。
4. 线程优先级的设置与获取。
5. 线程同步与互斥的实现方式：使用synchronized关键字。

练习：尝试创建一个多线程程序，模拟多个售票窗口售卖火车票的过程。在这个过程中，需要注意线程同步与互斥问题，确保票数的正确性。