【JAVA】线程详解

于 2024-08-15 23:35:35 发布
阅读量1.9k 收藏 20
点赞数 44
分类专栏： JAVA复习 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37559642/article/details/141234073
版权

线程的基本概念

  • 在Java中，线程（Thread）是并发编程的基本单元。线程允许一个程序执行多个任务（代码路径），从而提高效率和响应性。下面是对Java线程的详细介绍，包括概念、实现方法、线程的生命周期、常见的线程管理工具和最佳实践等。

1. 线程的基本概念

  • 进程与线程：
    • 进程是操作系统中执行的一个程序实例，拥有独立的内存空间。
    • 线程是进程中的一个执行单元，一个进程可以包含多个线程，这些线程共享进程的内存空间和资源。
  • 多线程的意义：
    • 并发：多线程可以让程序执行多个任务，提高应用程序的性能，尤其是在I/O密集型任务中，如文件读取、网络请求等。
    • 并行：在多核处理器上，多个线程可以同时在不同的CPU核心上运行，实现真正的并行处理。

2. 创建线程的两种方式

2.1 继承Thread类

通过继承Thread类并重写run()方法来定义线程，然后调用start()方法启动线程。

示例代码：

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

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程，run()方法将被执行
    }
}

2.2 实现Runnable接口

通过实现Runnable接口的run()方法，然后将其传递给Thread对象并调用start()方法启动线程。这种方式更为灵活，因为它允许类继承其他类，同时实现多线程。

示例代码：

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

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start(); // 启动线程，run()方法将被执行
    }
}

3. 线程的生命周期

Java中的线程在运行时经历不同的状态，每个状态都有特定的意义和作用。

  • 新建状态（New）：线程对象被创建，但还未启动。
  • 就绪状态（Runnable）：线程已经启动，等待CPU分配时间片执行。
  • 运行状态（Running）：线程获得CPU时间片，正在执行run()方法中的代码。
  • 阻塞状态（Blocked/Waiting/Timed Waiting）：线程因某种原因被阻塞，等待某个条件的满足（如等- 待锁释放、计时器到期等）。
  • 终止状态（Terminated）：线程的run()方法执行完毕或因未捕获的异常而终止。

4. 线程的常见操作

4.1 线程休眠（sleep()）

Thread.sleep(milliseconds)方法使当前线程暂停执行一段时间，但不释放锁。

示例代码：

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Thread sleeping...");
            Thread.sleep(2000); // 线程休眠2秒
            System.out.println("Thread woke up.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4.2 线程等待（join()）

join()方法在Java中用于线程间的协调和等待。它使一个线程等待另一个线程完成执行后才继续执行

示例代码：

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread is running: " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程

        try {
            thread.join(); // 主线程等待thread线程结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Thread has finished, main thread resumes.");
    }
}

解释：

  • thread.join()使得主线程在thread线程执行完之前不会继续执行。
  • 主线程在thread线程的run()方法执行完成后，才会继续执行System.out.println(“Thread has finished, main thread resumes.”);。

4.3 线程中断（interrupt()）

interrupt()方法用于中断线程的执行，通常与InterruptedException结合使用。

示例代码：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread running...");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread was interrupted.");
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        Thread.sleep(3000);
        thread.interrupt(); // 中断线程
    }
}

4.4 线程优先级（setPriority()）

线程的优先级决定了线程获得CPU时间片的机会大小。Java线程优先级范围从Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10），默认优先级为Thread.NORM_PRIORITY（5）。

示例代码：

Thread thread = new Thread(new MyRunnable());
thread.setPriority(Thread.MAX_PRIORITY); // 设置最高优先级
thread.start();

5. 线程同步与互斥

在多线程环境中，多个线程可能同时访问共享资源，为了避免数据不一致，需要对共享资源的访问进行同步控制。

5.1 同步块（synchronized）

synchronized关键字用于锁定一个方法或代码块，使得同一时间只有一个线程可以执行该方法或代码块。

示例代码：

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + counter.getCount());
    }
}

5.2 线程通信（wait() 和 notify()）

wait()和notify()/notifyAll()方法用于线程间的通信，通常与synchronized关键字结合使用，用来协调线程之间的合作。

示例代码：

class SharedResource {
    private boolean available = false;

    public synchronized void produce() {
        while (available) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        available = true;
        System.out.println("Produced resource.");
        notify();
    }

    public synchronized void consume() {
        while (!available) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        available = false;
        System.out.println("Consumed resource.");
        notify();
    }
}

public class Main {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();

        Thread producer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                resource.produce();
            }
        });

        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                resource.consume();
            }
        });

        producer.start();
        consumer.start();
    }
}

6. 高级线程管理工具

6.1 ExecutorService

ExecutorService是Java并发库提供的一个高级线程池管理工具，允许开发者管理和复用线程。

示例代码：

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

public class Main {
    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();
    }
}

6.2 ForkJoinPool

ForkJoinPool是Java 7引入的一个并行处理框架，特别适合处理大规模的任务分解与并行执行。

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

class SumTask extends RecursiveTask<Integer> {
    private final int[] arr;
    private final int start;
    private final int end;

    public SumTask(int[] arr, int start, int end) {
        this.arr = arr;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= 10) {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += arr[i];
            }
            return sum;
        } else {
            int mid = (start + end) / 2;
            SumTask leftTask = new SumTask(arr, start, mid);
            SumTask rightTask = new SumTask(arr, mid, end);
            leftTask.fork(); // 异步执行左侧任务
            return rightTask.compute() + leftTask.join(); // 计算右侧任务并等待左侧任务完成
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int[] arr = new int[100];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1; // 初始化数组为1到100
        }

        ForkJoinPool pool = new ForkJoinPool();
        SumTask task = new SumTask(arr, 0, arr.length);
        int result = pool.invoke(task); // 启动任务并获取结果
        System.out.println("Sum: " + result);

        pool.shutdown(); // 关闭线程池
    }
}

7. 总结

  • 线程创建：可以通过继承Thread类或实现Runnable接口来创建线程。
  • 线程生命周期：包括新建、就绪、运行、阻塞和终止状态。
  • 线程操作：包括线程休眠、线程中断和线程优先级的设置。
  • 线程同步：使用synchronized关键字来避免多个线程访问共享资源时产生冲突。
  • 线程通信：通过wait()和notify()等方法来实现线程间的协作。
  • 高级线程管理：ExecutorService和ForkJoinPool提供了更高级的线程管理和并行处理能力。

理解这些基本概念和操作是掌握Java多线程编程的基础，有助于提高程序的并发性和性能。

弗瑞德学JAVA
关注
专栏目录
Java线程详解大全
08-03
Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程
java 线程详解及线程与进程的区别
08-31
Java线程详解与进程的区别是理解多任务并发执行的关键。在计算机系统中，进程和线程是两种不同的执行单元。 1. **进程**：每个进程都有独立的内存空间，这意味着不同进程之间的数据不能直接共享。例如，当你打开多...
java 线程详解
热门推荐
muranfei的博客
07-02 1万+
一、线程的基本概念 一个线程就是在进程中的一个单一的顺序控制流. 而单个进程可以拥有多个并发执行的任务，每个任务都好像有自己的CPU一样，而其底层的机制就是切分CPU的时间，也就是CPU将轮流给每个任务分配其占用时间。 每个任务都觉得自己在一直占用CPU，而事实上是将CPU时间划分成片段分配给所有的任务。 在多个CPU的环境下，多线程的运作，可以极大的提供程序的运行速度，这就是线程存在的意...
Java线程总结
baggio785的专栏
04-05 1756
作者的blog:(http://blog.matrix.org.cn/page/Kaizen)首先要理解线程首先需要了解一些基本的东西，我们现在所使用的大多数操作系统都属于多任务，分时操作系统。正是由于这种操作系统的出现才有了多线程这个概念。我们使用的windows,linux就属于此列。什么是分时操作系统呢，通俗一点与就是可以同一时间执行多个程序的操作系统，在自己的电脑上面，你是不是一边听歌
java学习笔记_线程
今生今世的专栏
05-03 1041
一、Java线程：概念与原理 1、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多
Java线程详解
yzzzf_的博客
03-18 251
新手学Java
Java中的线程
每天进步一点点。
03-04 1万+
转载请标明出处：http://blog.csdn.net/zhangxingping Java中的线程 进程和线程 在并发性程序中，有两个基本的执行单元：进程和线程。在Java编程语言中，并发编程大多数情况下都是和线程相关。然而，进程也是很重要的。   一个计算机系统中通常都有很多活动的进程和线程。这一点即使是在只有一个执行核心，并且在给定时刻只能执行一个线程的系统中都是存在的。
java线程详解
01-22
### Java线程详解 #### 一、扩展`java.lang.Thread`类 在Java中实现多线程的一个方式是通过继承`java.lang.Thread`类。这种方式简单直观，但也有一定的局限性，比如不能再次继承其他类。 **示例代码**： ```java...
Java 线程详解
06-27
Java 线程详解 在 Java 编程语言中，线程是一种基本的编程单元，它允许开发者在一个程序中执行多个任务。线程是轻量级的进程，它可以与其他线程共享同一个进程的资源。线程的使用可以提高程序的效率和响应速度。 ...
Java-并发-Java线程中断与停止线程详解
12-22
  Java 中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行，而是被中断的线程根据中断状态自行处理。即“线程中断”并不是字面意思——线程真的中断了，而是设置了中断标志...
1.线程的概念
08-22 148
和其他多数计算机语言不同，Java内置支持多线程编程（multithreaded programming）。 多线程程序包含两条或两条以上并发运行的部分。程序中每个这样的部分都叫一个线程（thread），每个线程都有独立的执行路径。因此，多线程是多任务处理的一种特殊形式。 你一定知道多任务处理，因为它实际上被所有的现代操作系统所支持。然而，多任务处理有两种截然不同的类型：基于进程的和基
JAVA线程
最新发布
互联网底层民工的博客
06-26 9501
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值