当前位置：
  1. 首页
  2. java
  3. 正文
本文介绍: Java是一种支持多线程编程的编程语言。多线程是指在同一程序中同时执行多个独立任务的能力。在Java中，线程是一种轻量级的子进程，它是程序中的最小执行单元。Java的多线程编程可以通过两种方式实现：继承Thread类或实现Runnable接口。所有的程序都是通过main方法开始执行的。当一个Java程序启动时，JVM（Java虚拟机）会自动创建一个主线程，该线程负责执行main方法。在多线程编程中，你可以创建额外的线程来执行其他任务。

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提供了一些关键字和方法来控制线程的执行，其中一些关键字包括：

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

线程的状态有以下几种：

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

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

在这里插入图片描述

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

在这里插入图片描述

2.线程的生命周期

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

  1. 新建状态（New）：
  2. 就绪状态（Runnable）：
  3. 运行状态（Running）：
  4. 阻塞状态（Blocked）：
  5. 等待状态（Waiting）：
  6. 超时等待状态（Timed Waiting）：
  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;

注意，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;

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

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 类：

    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();

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

原文地址:https://blog.csdn.net/Sion_one/article/details/134683563

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。

如若转载，请注明出处：http://www.7code.cn/show_18185.html

如若内容造成侵权/违法违规/事实不符，请联系代码007邮箱：suwngjj01@126.com进行投诉反馈，一经查实，立即删除！

上一篇 EUREKA: HUMAN-LEVEL REWARD DESIGN VIACODING LARGE LANGUAGE MODELS
下一篇 关于java agent

相关文章

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

插入图片
浏览器会保存昵称、邮箱和网站cookies信息，下次评论时使用。