Java多线程-第20章

Java多线程-第20章

1.创建线程

Java是一种支持多线程编程的编程语言。多线程是指在同一程序中同时执行多个独立任务的能力。在Java中，线程是一种轻量级的子进程，它是程序中的最小执行单元。Java的多线程编程可以通过两种方式实现：继承Thread类或实现Runnable接口。

1. 继承Thread类：

   class MyThread extends Thread {
       public void run() {
           // 线程执行的代码
       }
   }
   

   创建并启动线程：

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

2. 实现Runnable接口：

   class MyRunnable implements Runnable {
       public void run() {
           // 线程执行的代码
       }
   }
   

   创建并启动线程：

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

所有的程序都是通过main方法开始执行的。当一个Java程序启动时，JVM（Java虚拟机）会自动创建一个主线程，该线程负责执行main方法。在多线程编程中，你可以创建额外的线程来执行其他任务。

Java提供了一些关键字和方法来控制线程的执行，其中一些关键字包括：

• synchronized：用于控制多个线程访问共享资源时的同步问题。
• wait()、notify()、notifyAll()：用于实现线程间的通信和协调。
• sleep(long milliseconds)：让线程休眠一段时间。
• join()：等待一个线程终止。
• yield()：让出CPU执行权，让其他线程执行。

多线程编程的主要挑战之一是避免竞态条件（Race Condition）和死锁（Deadlock）。竞态条件发生在多个线程试图同时访问和修改共享数据时，而死锁则是线程相互等待对方释放资源，导致所有线程都无法继续执行的情况。

线程的状态有以下几种：

• 新建（New）： 线程已经创建，但还没有开始执行。
• 就绪（Runnable）： 线程可以开始执行，等待CPU时间片。
• 运行（Running）： 线程正在执行。
• 阻塞（Blocked）： 线程被阻塞，等待某个事件的发生。
• 死亡（Terminated）： 线程执行完成。

请注意，Java的多线程编程也有一些高级的概念和工具，如线程池、Callable和Future等，用于更灵活地处理多线程任务。

实例1：让线程循环打印1-10的数字

实例2：让窗口中的图标动起来

2.线程的生命周期

Java线程的生命周期描述了一个线程从创建到运行再到结束的整个过程，它包括多个状态，每个状态代表了线程在不同阶段的状态。Java线程的生命周期可以分为以下几个状态：

1. 新建状态（New）：
   • 当线程对象被创建时，它处于新建状态。
   • 此时，线程还没有开始执行。
2. 就绪状态（Runnable）：
   • 当线程调用start()方法后，线程进入就绪状态。
   • 此时，线程已经准备好运行，等待获取CPU时间片。
3. 运行状态（Running）：
   • 当就绪状态的线程获取到CPU时间片时，线程进入运行状态。
   • 此时，线程正在执行其任务。
4. 阻塞状态（Blocked）：
   • 线程在运行过程中，可能由于某些原因需要暂时放弃CPU时间片，进入阻塞状态。
   • 典型的例子包括等待I/O完成、等待获取锁、等待通知等。
   • 当阻塞条件解除时，线程会重新进入就绪状态。
5. 等待状态（Waiting）：
   • 线程在等待某个条件满足时，会进入等待状态。
   • 调用Object.wait()、Thread.join()、LockSupport.park()等方法可以使线程进入等待状态。
   • 等待状态的线程需要其他线程通知或中断才能继续执行。
6. 超时等待状态（Timed Waiting）：
   • 线程在等待一段时间后会进入超时等待状态。
   • 调用带有超时参数的Object.wait()、Thread.sleep()、Thread.join()等方法会导致线程进入超时等待状态。
7. 终止状态（Terminated）：
   • 线程执行完任务或者发生了未捕获的异常时，线程进入终止状态。
   • 一个终止状态的线程不能再次启动。

这些状态构成了线程的生命周期，如下图所示：

New -> Runnable -> (Running) -> Blocked -> (Runnable) -> (Terminated)
              -> Waiting -> (Runnable) -> (Terminated)
              -> Timed Waiting -> (Runnable) -> (Terminated)

注意，生命周期中的括号表示这些状态可能是短暂的，线程可能在运行、等待、超时等待等状态间切换。在实际的多线程应用中，正确地管理线程生命周期是至关重要的，以避免潜在的问题，如死锁、竞态条件等。

3.操作线程的方法

4.1线程的休眠

线程休眠是通过Thread.sleep(long milliseconds)方法实现的。这个方法让当前正在执行的线程在指定的时间内进入休眠状态（即暂停执行），单位是毫秒。在指定时间过去或者线程被中断时，线程将恢复执行。

方法签名为：

public static native void sleep(long millis) throws InterruptedException;

• millis：休眠时间，以毫秒为单位。

注意，sleep方法可能抛出InterruptedException异常，因为线程在休眠时可以被其他线程中断。在处理中断时，可以选择捕获该异常并处理，或者将异常继续传播出去。

4.2线程的加入

在Java中，可以使用join()方法来等待一个线程完成其执行。join()方法的作用是使当前线程等待调用join()方法的线程执行结束，然后再继续执行当前线程。

方法签名为：

public final void join() throws InterruptedException;

或者可以使用带有超时参数的join(long millis)方法：

javaCopy code
public final synchronized void join(long millis) throws InterruptedException;

• millis：等待的最大时间（以毫秒为单位）。

以下是一个简单的例子，演示了线程的加入：

class MyThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Task " + i + " in progress by " + Thread.currentThread().getName());
            try {
                // 模拟任务执行时间
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class JoinExample {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        // 启动线程1
        thread1.start();

        try {
            // 等待线程1执行完成，然后再继续执行主线程
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 启动线程2
        thread2.start();

        // 主线程继续执行
        System.out.println("Main thread continues its work.");
    }
}

在这个例子中，主线程启动了thread1，然后调用thread1.join()等待thread1执行完成，接着启动了thread2。由于join()方法会使主线程等待被调用的线程执行完成，所以在这个例子中主线程会等待thread1执行完成后再启动thread2。

4.3线程的中断

线程的中断是一种线程间的协作机制，它允许一个线程通知另一个线程，以请求它停止正在执行的任务。线程的中断通过调用interrupt()方法来触发。

1. 中断线程：

   • 使用interrupt()方法中断线程。

     Thread myThread = new MyThread();
     myThread.start();
     // ...
     myThread.interrupt();  // 中断线程
     

   • interrupt()方法会设置线程的中断标志位，但并不会立即停止线程的执行。线程需要检查自己的中断状态并在适当的时候终止执行。

2. 检查中断状态：

   • 使用Thread.interrupted()方法检查当前线程的中断状态，并清除中断状态。

     if (Thread.interrupted()) {
         // 线程已被中断，执行相应的处理
     }
     

   • 或者使用isInterrupted()方法检查线程的中断状态而不清除中断状态。

     if (myThread.isInterrupted()) {
         // 线程已被中断，执行相应的处理
     }
     

3. 处理中断：

   • 在线程的执行过程中，可以通过检查中断状态来决定是否停止执行。

     public void run() {
         while (!Thread.interrupted()) {
             // 执行任务
         }
     }
     

   • 或者在抛出InterruptedException异常的地方处理中断。

     public void run() {
         try {
             while (true) {
                 // 执行任务
                 if (Thread.interrupted()) {
                     throw new InterruptedException();
                 }
             }
         } catch (InterruptedException e) {
             // 处理中断异常
         }
     }
     

   • 在处理中断时，可以选择终止线程的执行，或者采取其他适当的措施。

中断通常用于优雅地停止线程，而不是强制终止线程。这种协作的方式允许线程在中断请求到来时，完成正在进行的工作，并进行清理工作，提高程序的健壮性。

实例3：单击按钮停止进度条滚动

4.4线程的礼让

线程的礼让是指一个线程表明自己愿意让出当前的CPU执行时间，以便让其他线程有机会执行。我们可以使用Thread.yield()方法来实现线程的礼让。

方法签名为：

public static native void yield();

Thread.yield()方法是一个静态方法，调用它的线程会让出一些时间片，以便其他具有相同或更高优先级的线程有机会执行。然而，yield()方法并不能保证线程会让出CPU执行权，它只是向调度器发出一个提示。

5.线程的优先级

线程调度器使用线程的优先级来决定哪个线程应该优先执行。线程的优先级是一个整数值，范围从Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10）。默认情况下，每个线程的优先级都是Thread.NORM_PRIORITY（5）。

线程的优先级可以通过setPriority(int priority)方法进行设置。该方法必须在启动线程之前调用。

以下是设置线程优先级的例子：

class MyThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Task " + i + " in progress by " + Thread.currentThread().getName());
        }
    }
}

public class PriorityExample {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        // 设置线程1的优先级为最高
        thread1.setPriority(Thread.MAX_PRIORITY);

        // 启动线程1
        thread1.start();
        // 启动线程2
        thread2.start();
    }
}

在这个例子中，thread1的优先级被设置为最高（Thread.MAX_PRIORITY），而thread2使用默认的优先级。在运行时，具有更高优先级的线程更有可能被调度执行，但并不能保证绝对顺序。

注意，线程优先级的调整并不是在所有平台上都能生效的，而且过度依赖线程优先级可能导致可移植性问题。在实际应用中，更重要的是编写稳健的多线程代码，而不是过分关注线程优先级。

实例4：观察不同优先级的线程执行完毕顺序

6.线程同步

线程同步是一种机制，用于防止多个线程同时访问共享资源，从而避免数据不一致性和竞态条件。在Java中，主要的线程同步机制包括使用synchronized关键字、wait()、notify()和notifyAll()方法、以及Lock和Condition接口等。

6.1线程安全

线程安全是指多个线程访问某个共享资源时，不会出现不确定的结果或导致不一致性的情况。在多线程环境中，如果没有适当的同步机制，共享的数据结构可能会被多个线程同时修改，从而导致数据不一致或其他问题。确保线程安全是多线程编程中非常重要的一个方面。

以下是一些确保线程安全的常见方式：

1. 使用同步方法： 在方法上使用 synchronized 关键字，确保一次只有一个线程可以执行该方法。

   public synchronized void synchronizedMethod() {
       // 同步的代码块
   }
   

2. 使用同步代码块： 在代码块中使用 synchronized 关键字，确保一次只有一个线程可以执行同步代码块。

   public void someMethod() {
       // 非同步代码
   
       synchronized (lockObject) {
           // 同步的代码块
       }
   
       // 非同步代码
   }
   

3. 使用 java.util.concurrent 包中的线程安全类： Java提供了一些线程安全的数据结构，如 ConcurrentHashMap、CopyOnWriteArrayList 等。

   Map<String, String> concurrentMap = new ConcurrentHashMap<>();
   List<String> copyOnWriteList = new CopyOnWriteArrayList<>();
   

4. 使用 Lock 和 Condition： 使用 Lock 接口及其实现类来提供更细粒度的同步控制。

   Lock lock = new ReentrantLock();
   Condition condition = lock.newCondition();
   
   lock.lock();
   try {
       // 临界区的代码
   } finally {
       lock.unlock();
   }
   

5. 使用 volatile 关键字： volatile 关键字可以保证变量的可见性，但不能解决复合操作的原子性问题。

   private volatile boolean flag = false;
   

6. 使用原子类： java.util.concurrent.atomic 包中提供了一些原子类，如 AtomicInteger、AtomicLong 等，用于执行原子操作。

   AtomicInteger atomicInt = new AtomicInteger(0);
   atomicInt.incrementAndGet();
   

确保线程安全是一个综合性的问题，需要在设计阶段考虑，并采用适当的同步措施。选择合适的同步机制取决于具体的应用场景和性能要求。在设计和实现多线程程序时，充分了解并考虑线程安全性是至关重要的。

实例5：开发线程安全的火车售票系统

6.2线程同步机制

线程同步机制是一组用于确保多个线程访问共享资源时不会发生竞态条件和数据不一致的技术。以下是一些常见的线程同步机制：

1. synchronized 关键字：

   • synchronized 关键字用于修饰方法或代码块，确保在同一时刻最多只有一个线程能够进入被 synchronized 修饰的方法或代码块。

   // 同步方法
   public synchronized void synchronizedMethod() {
       // 同步的代码块
   }
   
   // 同步代码块
   public void someMethod() {
       // 非同步代码
   
       synchronized (lockObject) {
           // 同步的代码块
       }
   
       // 非同步代码
   }
   

2. Lock 和 Condition 接口：

   • Lock 接口提供了比 synchronized 更灵活的锁定机制。通过 ReentrantLock 实现类，可以使用 lock() 和 unlock() 方法来控制临界区的访问。
   • Condition 接口用于在 Lock 上创建条件变量，通过 await()、signal() 和 signalAll() 方法实现更灵活的线程通信。

   Lock lock = new ReentrantLock();
   Condition condition = lock.newCondition();
   
   lock.lock();
   try {
       // 临界区的代码
   } finally {
       lock.unlock();
   }
   

3. volatile 关键字：

   • volatile 关键字用于声明变量，确保线程之间对该变量的写入和读取操作是可见的。它不提供原子性，仅仅保证了可见性。

   private volatile boolean flag = false;
   

4. Atomic 类：

   • java.util.concurrent.atomic 包中提供了一组原子类，如 AtomicInteger、AtomicLong，用于执行原子操作，避免竞态条件。

   AtomicInteger atomicInt = new AtomicInteger(0);
   atomicInt.incrementAndGet();
   

5. ReadWriteLock 接口：

   • ReadWriteLock 接口提供了读写锁，允许多个线程同时读取共享资源，但只允许一个线程写入。

   ReadWriteLock rwLock = new ReentrantReadWriteLock();
   rwLock.readLock().lock();
   // 读取共享资源的操作
   rwLock.readLock().unlock();
   
   rwLock.writeLock().lock();
   // 写入共享资源的操作
   rwLock.writeLock().unlock();
   

这些机制可以根据具体的应用场景选择使用，每种机制都有其适用的情况。合理选择同步机制可以提高多线程程序的性能和可维护性，避免潜在的并发问题。

代码007普通

打赏 收藏 海报 链接