第七篇：Java中的线程和并发

HYP_Coder

于 2024-09-17 19:48:18 发布

阅读量348

点赞数 18

分类专栏： JAVA专栏文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/HYP_Coder/article/details/142317925

版权

JAVA专栏专栏收录该内容

8 篇文章 0 订阅

订阅专栏

第七篇：Java中的线程和并发

Java中的线程和并发编程是构建高效、响应迅速的应用程序的关键技术。随着多核处理器的普及和计算任务的增加，理解和有效利用线程和并发编程技术变得尤为重要。本篇文章将全面介绍Java中的线程和并发，包括线程的基础知识、生命周期、线程同步机制以及Java并发包的核心组件。

1. 线程基础

1.1 线程的概念

线程是程序中最小的执行单位，是进程中的一个轻量级子任务。多线程允许一个程序在同一时间执行多个任务，从而提高了程序的效率和响应速度。在Java中，线程是实现并发的主要手段。每个Java应用程序至少有一个主线程，所有的线程共同在一个进程内运行。

线程的主要特点包括：

并发执行：多个线程可以并发执行，从而使程序在执行时能够同时处理多个任务。
资源共享：线程之间可以共享内存和资源，这使得它们之间的通信和数据交换变得更加直接和高效。
上下文切换：线程的创建和销毁会带来一定的开销，线程之间的上下文切换可能会影响性能。

1.2 创建和启动线程

在Java中，有两种主要方式可以创建和启动线程：

1.2.1 继承Thread类

创建一个线程类继承自Thread类，并重写其run()方法，然后通过调用start()方法启动线程。

java

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

java

1.2.2 实现Runnable接口

创建一个实现Runnable接口的类，并实现run()方法。然后通过Thread类的构造函数将Runnable实例传递给Thread对象，并调用start()方法启动线程。

java

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running");
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

java

2. 线程的生命周期

线程在其生命周期中经历多个状态。了解这些状态和状态转换对于调试和优化多线程应用程序至关重要。

2.1 线程状态

线程的生命周期包括以下几种状态：

新建（New）：线程被创建但尚未启动。
就绪（Runnable）：线程已经启动，但还没有获得CPU时间片来执行。
运行（Running）：线程正在执行run()方法。
阻塞（Blocked）：线程因等待某种资源或条件而无法继续执行，例如等待I/O操作完成或等待锁。
等待（Waiting）：线程被永久阻塞，直到其他线程通知它继续执行。可以通过Object.wait()方法进入等待状态。
超时等待（Timed Waiting）：线程在指定的时间段内处于等待状态，例如调用Thread.sleep()方法。
终止（Terminated）：线程执行完毕或被异常终止。

2.2 线程的状态转换

线程状态的转换是由各种事件和方法调用驱动的：

从新建到就绪：调用start()方法后，线程从新建状态变为就绪状态。
从就绪到运行：线程调度器选择就绪状态的线程进行运行，将其状态转换为运行状态。
从运行到阻塞：线程在等待资源时，例如锁被占用或I/O操作未完成，会进入阻塞状态。
从阻塞到就绪：当等待的条件满足后，线程会重新进入就绪状态，等待调度器再次分配CPU时间。
从运行到等待：线程调用wait()方法后进入等待状态，直到被通知或被中断。
从等待到就绪：调用notify()或notifyAll()方法后，线程会从等待状态返回到就绪状态。
从运行到终止：线程完成其任务或者因异常终止，会进入终止状态。

3. 线程同步

在多线程环境中，多个线程可能会同时访问共享资源，这可能导致数据不一致和程序错误。线程同步机制确保同一时刻只有一个线程可以访问共享资源，从而避免这种问题。

3.1 synchronized关键字

synchronized关键字用于控制对共享资源的访问。它可以用在方法或者代码块上：

3.1.1 同步方法

在方法声明上加上synchronized关键字，这样当一个线程调用该方法时，其他线程不能同时调用该方法。

java

public synchronized void synchronizedMethod() {
    // 访问共享资源的代码
}

3.1.2 同步代码块

将synchronized关键字用于代码块内，这样只有在获取了特定的锁时，线程才能执行代码块中的代码。这种方法允许更细粒度的锁控制。

java

public void method() {
    synchronized (this) {
        // 访问共享资源的代码
    }
}

3.2 死锁和避免死锁

死锁是指两个或多个线程在等待对方持有的资源，从而导致所有线程都无法继续执行。死锁常常是由于线程间不正确的锁管理导致的。避免死锁的方法包括：

避免嵌套锁：尽量减少锁的嵌套，避免在持有一个锁的情况下去请求另一个锁。
遵循固定的锁顺序：如果多个线程需要多个锁，确保它们以相同的顺序请求锁。
使用定时锁：使用tryLock()方法并设置超时时间，以避免无限期地等待锁。

java

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockAvoidance {
    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();

    public void method1() {
        try {
            if (lock1.tryLock() && lock2.tryLock()) {
                // 执行操作
            }
        } finally {
            lock1.unlock();
            lock2.unlock();
        }
    }
}

java

4. Java并发包

Java并发包（java.util.concurrent）提供了一系列用于简化并发编程的工具和类。它包括线程池、并发集合、同步辅助类等。

4.1 Executor框架

Executor框架是Java并发包中用于管理线程的工具。它提供了一种高效的线程池管理机制，用于替代手动创建和管理线程。核心接口包括：

Executor：最基础的接口，定义了execute(Runnable command)方法，用于提交任务。
ExecutorService：扩展了Executor接口，提供了任务提交和生命周期管理的功能。常用的方法包括submit()和shutdown()。
ScheduledExecutorService：扩展了ExecutorService接口，支持任务的调度执行，如周期性任务和延迟任务。

4.1.1 使用ExecutorService

java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorServiceDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.submit(() -> System.out.println("Task 1"));
        executor.submit(() -> System.out.println("Task 2"));
        executor.shutdown();
    }
}

java

4.2 Callable和Future

Callable接口是Runnable接口的扩展，它可以返回结果和抛出异常。与Callable配合使用的是Future接口，它代表一个异步计算的结果。

4.2.1 使用Callable和Future

java

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableFutureDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(1);
        Callable<Integer> task = () -> {
            Thread.sleep(1000);
            return 123;
        };
        Future<Integer> future = executor.submit(task);
        
        try {
            Integer result = future.get(); // 阻塞直到任务完成
            System.out.println("Task result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        
        executor.shutdown();
    }
}

java