java 线程、锁优缺点汇总及样例-个人总结

于 2024-08-07 10:39:40 发布
阅读量601 收藏 10
点赞数 10
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiahui343872220/article/details/140984785
版权

线程

1. 基本概念

线程的生命周期

  • NEW（新建）：线程对象被创建，但尚未调用 start() 方法。
  • RUNNABLE（可运行）：调用 start() 方法后，线程进入可运行状态，等待 CPU 调度。
  • BLOCKED（阻塞）：线程被阻塞，等待获取锁。
  • WAITING（等待）：线程等待另一个线程的通知或信号。
  • TIMED_WAITING（计时等待）：线程等待另一个线程的通知或信号，带有超时时间。
  • TERMINATED（终止）：线程执行完毕或因异常退出。

2. 创建线程的方式

2.1 继承 Thread 类

优点：简单易用，适合简单任务。缺点：无法继承其他类，灵活性较差。

代码示例：

// 继承 Thread 类创建线程 public class MyThread extends Thread { @Override public void run() { // 线程执行的任务 System.out.println("线程正在运行"); } public static void main(String[] args) { MyThread thread = new MyThread(); thread.start(); // 启动线程 } }

真实场景：适用于简单的后台任务，如日志记录、文件监控等场景。

2.2 实现 Runnable 接口

优点：可以实现多继承，灵活性高。缺点：需要额外的线程启动代码。

代码示例：

// 实现 Runnable 接口创建线程 public class MyRunnable implements Runnable { @Override public void run() { // 线程执行的任务 System.out.println("Runnable 正在运行"); } public static void main(String[] args) { Thread thread = new Thread(new MyRunnable()); thread.start(); // 启动线程 } }

真实场景：适用于需要实现复杂任务逻辑的场景，或在已有的类中实现多线程功能。

2.3 使用 Callable 接口

优点：可以返回结果并抛出异常。缺点：需要使用 Future 获取结果，使用稍微复杂。

代码示例：

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; // 实现 Callable 接口创建线程 public class MyCallable implements Callable<String> { @Override public String call() throws Exception { // 线程执行的任务 return "Callable 结果"; } public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService executor = Executors.newSingleThreadExecutor(); Future<String> future = executor.submit(new MyCallable()); // 获取线程返回的结果 System.out.println(future.get()); executor.shutdown(); // 关闭线程池 } }

真实场景：适用于需要异步计算并获取结果的任务，如数据处理、计算任务等。

3. 线程池

3.1 FixedThreadPool

优点：线程数固定，控制最大并发数。缺点：线程数固定，任务可能会排队等待。

代码示例：

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class FixedThreadPoolExample { public static void main(String[] args) { // 创建固定大小的线程池 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10); for (int i = 0; i < 20; i++) { final int taskId = i; fixedThreadPool.execute(() -> { // 执行任务 System.out.println("处理任务 " + taskId + " 在线程 " + Thread.currentThread().getName()); }); } fixedThreadPool.shutdown(); // 关闭线程池 } }

真实场景：适用于需要控制最大并发线程数的场景，如服务器处理请求、后台任务处理等。

3.2 CachedThreadPool

优点：线程数不固定，空闲线程可回收。缺点：可能导致线程数量过多，资源耗尽。

代码示例：

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CachedThreadPoolExample { public static void main(String[] args) { // 创建可缓存的线程池 ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); for (int i = 0; i < 20; i++) { final int taskId = i; cachedThreadPool.execute(() -> { // 执行任务 System.out.println("处理任务 " + taskId + " 在线程 " + Thread.currentThread().getName()); }); } cachedThreadPool.shutdown(); // 关闭线程池 } }

真实场景：适用于短时间内需要处理大量任务的场景，如实时数据处理、任务调度等。

3.3 ScheduledThreadPool

优点：支持定时和周期性任务。缺点：线程数固定，任务可能会排队等待。

代码示例：

import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class ScheduledThreadPoolExample { public static void main(String[] args) { // 创建定时任务线程池 ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); // 定时任务，每秒执行一次 scheduledThreadPool.scheduleAtFixedRate(() -> { System.out.println("定时任务执行，在线程 " + Thread.currentThread().getName()); }, 0, 1, TimeUnit.SECONDS); // 运行 5 秒后关闭线程池 Executors.newSingleThreadScheduledExecutor().schedule(() -> { scheduledThreadPool.shutdown(); }, 5, TimeUnit.SECONDS); } }

真实场景：适用于定时任务和周期性任务，如定时备份、周期性数据同步等。

3.4 SingleThreadExecutor

优点：保证任务顺序执行。缺点：效率较低，仅适用于顺序任务。

代码示例：

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class SingleThreadExecutorExample { public static void main(String[] args) { // 创建单线程池 ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); for (int i = 0; i < 5; i++) { final int taskId = i; singleThreadExecutor.execute(() -> { // 执行任务 System.out.println("处理任务 " + taskId + " 在线程 " + Thread.currentThread().getName()); }); } singleThreadExecutor.shutdown(); // 关闭线程池 } }

真实场景：适用于需要按顺序执行任务的场景，如日志处理、任务队列等。

3.5 ThreadPoolTaskExecutor

    • ThreadPoolTaskExecutor 是 Spring 提供的一个方便的包装类，基于 Java 的 ThreadPoolExecutor，用于执行异步任务。
  1. availableProcessors
    • Runtime.getRuntime().availableProcessors() 返回当前 JVM 可用的处理器核心数量。它用于动态设置线程池的大小，以适应不同的硬件环境。
  1. maxPoolSize
    • maxPoolSize 是线程池中允许的最大线程数。此代码中将其设置为可用处理器数量的一半，但最少为1。目的是避免创建过多的线程，从而提高系统的效率。
  1. corePoolSize
    • corePoolSize 是线程池中保持活跃的核心线程数。此代码中将其设置为最大线程数的一半，但最少为1。核心线程在空闲时不会被回收，确保线程池有足够的线程处理任务。
  1. Queue Capacity
    • setQueueCapacity(queueCapacity) 设置线程池的队列容量。队列用于存储等待执行的任务，当所有核心线程都在忙碌时，新任务会进入队列等待。
  1. Thread Name Prefix
    • setThreadNamePrefix(threadName) 设置线程池中线程的名称前缀，有助于调试和监控。
  1. RejectedExecutionHandler
    • setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()) 设置任务拒绝策略。当线程池达到最大线程数并且队列已满时，决定如何处理新任务。
  1. Keep Alive Seconds
    • setKeepAliveSeconds(keepAliveSeconds) 设置线程空闲时间，当线程空闲时间超过这个值时，非核心线程会被回收。

setRejectedExecutionHandler 策略说明

RejectedExecutionHandler 是 java.util.concurrent.ThreadPoolExecutor 的一个内部接口，用于处理当线程池已达最大线程数且队列已满时，无法执行新任务的情况。常见的拒绝策略包括：

  1. AbortPolicy

（默认策略）：

    • 抛出 RejectedExecutionException，通知调用者任务被拒绝。
    • 示例：

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());

  1. CallerRunsPolicy
    • 直接在调用者线程中运行该任务。如果线程池已经关闭，则丢弃该任务。
    • 优点：不会丢失任务，但可能会影响调用者线程的性能。
    • 示例：

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

  1. DiscardPolicy
    • 丢弃无法处理的任务，不抛出异常。
    • 示例：

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());

  1. DiscardOldestPolicy
    • 丢弃队列中最旧的未处理任务，然后重新尝试执行当前任务。
    • 示例：

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());

public ThreadPoolTaskExecutor createExecutor(int queueCapacity, String threadName, int keepAliveSeconds) { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); // 系统核心处理器数量 int availableProcessors = Runtime.getRuntime().availableProcessors(); // 最大线程数 是 系统核心处理器的 50% int maxPoolSize = Math.max(availableProcessors / 2, 1); // 核心线程数 是 最大线程数的 50% int corePoolSize = Math.max(maxPoolSize / 2, 1); // 配置核心线程数 executor.setCorePoolSize(corePoolSize); // 配置最大线程数 executor.setMaxPoolSize(maxPoolSize); // 配置队列大小 executor.setQueueCapacity(queueCapacity); // 配置线程池中的线程的名称前缀 executor.setThreadNamePrefix(threadName); // 配置线程池中的线程的存活时间 executor.setKeepAliveSeconds(keepAliveSeconds); // rejection-policy：当pool已经达到max size的时候，如何处理新任务 executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 执行初始化 executor.initialize(); return executor; }

4.锁

1. synchronized 锁

优点：简单易用，隐式锁定和解锁。缺点：可能导致性能瓶颈，阻塞线程。

代码示例：

public class SynchronizedExample { private int count = 0; // 使用同步方法保证线程安全 public synchronized void increment() { count++; } public void showCount() { System.out.println("当前计数: " + count); } public static void main(String[] args) { SynchronizedExample example = new SynchronizedExample(); Runnable task = () -> { for (int i = 0; i < 1000; i++) { example.increment(); } }; Thread t1 = new Thread(task); Thread t2 = new Thread(task); t1.start(); t2.start(); try { t1.join(); t2.join(); } catch (InterruptedException e) { e.printStackTrace(); } example.showCount(); // 输出结果应为2000 } }

真实场景：适用于需要简单同步的场景，如单例模式、数据一致性保障等。

2. ReentrantLock（重入锁）

优点：可重入，灵活性高，支持条件变量。缺点：需要显式锁定和解锁，代码复杂性增加。

代码示例：

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ReentrantLockExample { private final Lock lock = new ReentrantLock(); private int count = 0; public void increment() { lock.lock(); // 获取锁 try { count++; } finally { lock.unlock(); // 释放锁 } } public void showCount() { System.out.println("当前计数: " + count); } public static void main(String[] args) { ReentrantLockExample example = new ReentrantLockExample(); Runnable task = () -> { for (int i = 0; i < 1000; i++) { example.increment(); } }; Thread t1 = new Thread(task); Thread t2 = new Thread(task); t1.start(); t2.start(); try { t1.join(); t2.join(); } catch (InterruptedException e) { e.printStackTrace(); } example.showCount(); // 输出结果应为2000 } }

真实场景：适用于需要复杂锁操作的场景，如数据库操作、线程安全的数据结构等。

3. ReadWriteLock（读写锁）

优点：允许多个线程并发读取，写操作是排他性的。缺点：读写锁逻辑复杂，读操作较多时可能导致写操作等待时间增加。

代码示例：

import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadWriteLockExample { private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); private String data = "初始数据"; public String readData() { readWriteLock.readLock().lock(); // 获取读锁 try { return data; } finally { readWriteLock.readLock().unlock(); // 释放读锁 } } public void writeData(String newData) { readWriteLock.writeLock().lock(); // 获取写锁 try { data = newData; } finally { readWriteLock.writeLock().unlock(); // 释放写锁 } } public static void main(String[] args) { ReadWriteLockExample example = new ReadWriteLockExample(); Runnable readTask = () -> System.out.println("读取数据: " + example.readData()); Runnable writeTask = () -> example.writeData("新数据"); // 启动多个线程进行读写操作 for (int i = 0; i < 5; i++) { new Thread(readTask).start(); } for (int i = 0; i < 2; i++) { new Thread(writeTask).start(); } } }

真实场景：适用于读操作远多于写操作的场景，如缓存系统、配置读取等。

4. StampedLock（印章锁）

优点：比读写锁效率更高，支持无锁读操作。缺点：复杂性高，使用不当可能引入错误。

代码示例：

import java.util.concurrent.locks.StampedLock; public class StampedLockExample { private final StampedLock stampedLock = new StampedLock(); private String data = "初始数据"; public String readData() { long stamp = stampedLock.readLock(); // 获取读锁 try { return data; } finally { stampedLock.unlockRead(stamp); // 释放读锁 } } public void writeData(String newData) { long stamp = stampedLock.writeLock(); // 获取写锁 try { data = newData; } finally { stampedLock.unlockWrite(stamp); // 释放写锁 } } public static void main(String[] args) { StampedLockExample example = new StampedLockExample(); Runnable readTask = () -> System.out.println("读取数据: " + example.readData()); Runnable writeTask = () -> example.writeData("新数据"); // 启动多个线程进行读写操作 for (int i = 0; i < 5; i++) { new Thread(readTask).start(); } for (int i = 0; i < 2; i++) { new Thread(writeTask).start(); } } }

真实场景：适用于读多写少的场景，对性能要求高的应用，如高频率数据查询和修改的系统。

忄习惯忄
关注
  • 10
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
大数据面试总结《十六》--面试题规律总结
weixin_41045909的博客
03-28 4364
关于Java的面试题：关于虚拟机的面试题： 1.hashmap底层? 2.Java进程中断怎么处理? 3.介绍下面向对象? 4.介绍下多态? 5.方法重载和重写? 6.这俩哪个属于多态? 7.说下多线程? 8.实现方式有哪些，区别? 9.同步锁 互斥，为什么常量不能做锁? 10.说下反射，都是做什么的? 11.反射机制怎么实现的? 12.linkedlist和arraylist的区别? 13.h...
java 多线程-锁详解及示例代码
09-01
Java 多线程编程中，锁机制是保证并发安全的关键技术。本文主要讲解了Java中锁的基本概念、使用方式以及示例代码，旨在帮助开发者理解如何在多线程环境下实现线程安全。 首先，Java从5版本开始引入了`java.util....
Java并发编程-Java中的锁
XiaoCai
03-20 1092
ava 中的锁是用于控制多线程对共享资源访问的一种机制，以防止数据的不一致性和脏读。Java 提供了多种锁机制，包括内置的同步机制（synchronized）和在 `java.util.concurrent.locks` 包中提供的显式锁（如 `ReentrantLock`）等。
4 万字 102 道Java经典面试题总结（2024修订版）- 多线程篇
学Java，找哪吒
04-09 1994
《10万字208道Java经典面试题总结(附答案)》2024修订版
多线程总结
weixin_47474875的博客
07-28 45
多线程总结
牛逼！Java 从入门到精通，超全汇总版
热门推荐
程序员cxuan的个人主页
05-06 7万+
文章目录Java 基础Head First JavaJava 核心技术卷一Java 编程思想设计模式Head First 设计模式图解设计模式设计模式重学 Java 设计模式Java 进阶Java 并发编程实战Java 并发编程艺术Java 并发编程之美图解Java多线程设计模式JVM深入理解 Java 虚拟机Java 虚拟机规范HotSpot 实战自己动手写 Java 虚拟机MySQLMySQL 基础教程SQL 基础教程深入浅出 MySQLMySQL 必知必会SQL 必知必会高性能 MySQLMySQL
java多线程整理（一）
yrsg666的博客
12-29 154
一、基础整理 1、多线程的实际应用： 实际项目中对于一些主线程无需等待，但是又需要做一些其他操作并且此操作又不影响主线程执行结果的时候，条件允许情况下我们都可以用多线程来实现比如某个请求返回结果的多次处理，直接返回请求，并且对返回结果进行多种处理，这时候完全可以开异步线程去处理其他操作；还有就是需要将一个主线程拆分成多个子线程去处理，主线程阻塞住等待异步线程依次返回请求后汇总然后返回请求结果，尤其是涉及到多个分支请求时候我们也不会去用主线程一个个请求；还有一些其他的比如mysql数据进比较猛，我们改怎么解决
【持续更新】Java高级工程师面试常见问题汇总
LANXIAMAO的博客
04-09 354
READ UNCOMMITTED（读未提交数据）：允许事务读取未被其他事务提交的变更数据，会出现脏读、不可重复读和幻读问题。READ COMMITTED（读已提交数据）：只允许事务读取已经被其他事务提交的变更数据，可避免脏读，仍会出现不可重复读和幻读问题。REPEATABLEREAD（可重复读）：确保事务可以多次从一个字段中读取相同的值，在此事务持续期间，禁止其他事务对此字段的更新，可以避免脏读和不可重复读，仍会出现幻读问题。
大数据学习总结+JAVA学习总结+大数据面试+java面试+大数据java异常总结
qq_39348280的博客
09-28 3906
文章目录一、java模块面试问题1.动态代理2.浏览器禁用Cookie后的Session处理3.主从复制的流程[重要]5.redis的数据类型[重要]6.Junit测试的注解7、缓存问题二、项目中java模块的难点异常[重要]1.MultipartiFile图片从前台用Restfull到后台问题2.批量删除参数问题3.前台后台的请求方式post,get,del4.后台给页面响应string(返回值时String)的时候就需要进行处理5.导出到excel表格的时候JSON反序列化问题6.埋点，统计用户输入特征
请求合并java场景_高并发场景-请求合并（一）SpringCloud中Hystrix请求合并
weixin_39862847的博客
03-01 285
背景在互联网的高并发场景下，请求会非常多，但是数据库连接池比较少，或者说需要减少CPU压力，减少处理逻辑的，需要把单个查询，用某些手段，改为批量查询多个后返回。 如：支付宝中，查询“个人信息”，用户只会触发一次请求，查询自己的信息，但是多个人同时这样做就会产生多次数据库连接。为了减少连接，需要在JAVA服务端进行合并请求，把多个“个人信息”查询接口，合并为批量查询多个“个人信息”接口，然后以个人信...
Java多线程-知识点梳理和总结-超详细-面试知识点.docx
12-17
Java多线程的优缺点是什么？ 2. 什么是volatile关键字？volatile关键字的作用是什么？ 3. 什么是Java内存模型？Java内存模型的作用是什么？ 4. 什么是Happens-Before关系？Happens-Before关系的作用是什么？ 5. 什么...
Java创建线程三种方式的优缺点
08-26
Java创建线程三种方式的优缺点 Java创建线程主要有三种方式：继承Thread类创建线程、实现Runnable接口创建线程和实现Callable和Future创建线程。每种方式都有其优缺点，在实际开发中，选择合适的方式非常重要。 ...
java 线程锁详细介绍及实例代码
08-31
在Java编程语言中，线程同步是多线程环境下确保数据一致性的重要机制，而线程锁则是实现同步的关键工具。本文将深入探讨Java线程锁的使用、原理以及实例代码。 一、线程锁的概念与作用 线程锁，也称为互斥锁，主要...
Java多线程-线程的同步与锁的问题
09-01
Java多线程编程中，线程同步是一种解决并发问题的关键技术。当多个线程同时访问共享资源时，可能会引发数据不一致性和竞态条件。线程同步的主要目标是确保同一时间只有一个线程能够访问特定的代码段，以避免数据损坏...
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 395
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 150
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
枚举工具类
qq_43049583的博客
08-04 372
java枚举工具类
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1226
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值