JUC 练习代码，让你深入立即 JUC

最新推荐文章于 2025-11-23 21:07:11 发布
原创 最新推荐文章于 2025-11-23 21:07:11 发布 · 186 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #面试 #JUC

例1：

public class MyServlet extends HttpServlet {
// 是否安全
Map<String, Object> map = new HashMap<>();
// 是否安全
String S1 = "...";
// 是否安全
final String s2 = "...";
Date D1 = new Date();
// 是否安全
final Date D2 = new Date();

public void doGet(HttpServletRequest request, HttpServletResponse response) {
		// 使用上述变量
	}
}
分析

image-20250319215419351

答案

Map<String, Object> map = new ConcurrentHashMap<>();
final LocalDateTime s2 = LocalDateTime.now();
LocalDateTime D1 = LocalDateTime.now();
final LocalDateTime D2 = LocalDateTime.now();

例二

public class MyServlet extends HttpServlet {
	// 是否安全？
	private UserService userService = new UserServiceImpl();
	
	public void doGet(HttpServletRequest request, HttpServletResponse response) {
		userService.update(...);
	}
}
public class UserServiceImpl implements UserService {
	// 记录调用次数
	private int count = 0;
	
	public void update() {
		// ...
		count++;
	}
}
思路

image-20250319215650756

答案

public class MyServlet extends HttpServlet {
    private UserService userService = new UserServiceImpl();
    
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update();
    }
}

public class UserServiceImpl implements UserService {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void update() {
        // ...
        count.incrementAndGet();
    }
}

例三

@Aspect
@Component
public class MyAspect 【
	// 是否安全
	private long start = 0L;
	
	@Before("execution(* *(..))")
	 public void before() {
	 	start = System.nanoTime();
	 }
	@After("execution(* *(..))")
	public void after() {
		long end = System.nanoTime();
		System.out.println("cost time:" + (end - start));
	}
}
思路
思路一
@Aspect
@Componet
public class MyAspect {
    private ThreadLocal<Long> startTime = new ThreadLocal<>();
    
    @Before("execution(* *(..))")
    public void before() {
        startTime.set(System.nanoTime());
    }
    
    @After("execution(* *(..))")
    public void after() {
        long end = System.nanoTime();
        long start = startTime.get();
        System.out.println("cost time:" + (end - start));
        startTime.remove(); // 清理 ThreadLocal， 防止内存泄漏
    }
}

对象

  • 线程安全，每个线程都有自己的 start值
  • 简单易用，适用这种需要在线程间隔离状态的场景

缺点

  • 需要手动清理 ThreadLocal (调用 remove()), 否则可能会导致内存泄漏(尤其是在线程池场景中)
思路二
@Aspect
@Component
public class MyAspect {
    @Around("execution(* *(..))")
    public void around(ProceddingJoinPoint joinPoint) throws Thtowable {
        long start = System.nanoTime();
        joinPoint.proceed() // 执行目标方法
        long end = System.nanoTime();
        System.out.println("cost time:" + (end - start));
    }
}

答案

@Aspect
@Component
public class MyAspect {
    private ThreadLoca<Long> startTime = new ThreaddLocal<>();
    
    @Before("execution(* *(..))")
    public void before() {
        startTime.set(System.nanoTime());
    }
    
    @After("execution( *(..))")
    public void after() {
        long end = System.nanoTime();
        long start = System.get();
        System.out.println("cost time:" + (end - start));
        startTime.remove(); // 清理 ThreadLocal, 防止内存泄漏
    }
}

例四

public class MyServlet extends HttpServlet {
	// 是否安全
	private UserService userService = new UserServiceImpl();
	
	public void doGet(HttpServletRequest request, HttpServletResponse response) {
		userService.update(...);
	}
}

public class UserServiceImpl implements UserService {
	// 是否安全
	private UserDao userDao = new UserDaoImpl();
	
	public void update() {
		userDao.update();
	}
}

public class UserDaoImpl implements UserDao {
	public void update() {
		String sql = "update user set password = ? where username = ?"
		// 是否安全
		try (Connection conn = DriverManager.getConnection("","","")) {
			// ...
		} catch (Exception e) {
			// ...
		}
	}
}
思路

image-20250319221845169

image-20250319221857971

image-20250319221913120

答案

public class MyServlet extends HttpServlet {
    private UserService userService = new UserServiceImpl();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();

    public void update() {
        userDao.update();
    }
}

public class UserDaoImpl implements UserDao {
    private DataSource dataSource; // 通过依赖注入获取连接池

    public UserDaoImpl(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void update() {
        String sql = "update user set password = ? where username = ?";
        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, password);
            pstmt.setString(2, username);
            pstmt.executeUpdate();
        } catch (Exception e) {
            // ...
        }
    }
}

例5

public class MyServlet extends HttpServlet {
	// 是否安全
	private UserService userService = new UserServiceImpl();
	
	public void doGet(HttpServletRequest request, HttpServletResponse response) 【
		userService.update(...);
	}
}

public class UserServiceImpl implements UserService {
	// 是否安全
	private UserDao userDao = new UserDaoImpl();
	
	public void update() {
		userDao.update();
	}
}

public class UserDaoImp implements UserDao {
	// 是否安全
	private Connection conn = null;
	
	public void update() throws SQLException {
		String sql = "update user set password = ? where username = ?"
		conn = DriverManager.getConnection("","","");
		// ...
		conn.close();
	}
}
思路

image-20250319223912910

答案

public class MyServlet extends HttpServlet {
    private UserService userService = new UserServiceImpl();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();

    public void update() {
        userDao.update();
    }
}

public class UserDaoImpl implements UserDao {
    private DataSource dataSource; // 通过依赖注入获取连接池

    public UserDaoImpl(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void update() throws SQLException {
        String sql = "update user set password = ? where username = ?";
        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            // 设置参数
            pstmt.setString(1, password);
            pstmt.setString(2, username);
            pstmt.executeUpdate();
        }
    }
}

例6

public class MyServlet extedns HttpServlet {
	// 是否安全
	private UserService userService = new UserServiceImpl();
	
	public void doGet(HttpServletRequest request, HttpServletReponse response) {
			userService.update(...);
		}
}

public class UserServiceImpl implements UserService {
	pubilc void update() {
		UserDao userDao = new UserDaoImpl();
		userDao.update();
	}
}

public class UserDaoImpl implements UserDao  {
	// 是否安全
	private Connection = null;
	public void update() throws SQLException {
		String sql = "update user set password = ? where username  ?"
		conn = DriverManager.getConnection("", "", "")l
		// ...
		conn.close();
	}
}
思路

image-20250319224224282

答案

public class UserDaoImpl implements UserDao {
    private DataSource dataSource; // 通过依赖注入获取连接池

    public UserDaoImpl(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void update() throws SQLException {
        String sql = "update user set password = ? where username = ?";
        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            // 设置参数
            pstmt.setString(1, password);
            pstmt.setString(2, username);
            pstmt.executeUpdate();
        }
    }
}

例7

public abstract class Test {
	
	public void bar() {
		// 是否安全
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		foo(sdf);
	}
	
	public abstract foo(SimpleDateFormat sdf);
	
	public static void main(String[] args) {
		new Test().bar();
	}
}

其中 foo 的行为是不确定的，可能导致不安全的发生，被称为外星方法

public void foo(SimpleDateFormat sdf) {
	String dateStr = "1999-10-11 00:00:00";
	for (int i = 0; i < 20; i++) {
		new Thread(() -> {
			try {
				sdf.parse(dateStr);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}).start();
	}
}

请比较 JDK 中 String 类的实现

思路

image-20250319224336524

答案

public void foo() {
    String dateStr = "1999-10-11 00:00:00";
    for (int i = 0; i < 20; i++) {
        new Thread(() -> {
            try {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                sdf.parse(dateStr); // 每个线程有自己的 sdf 实例
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

例八

private static Integer i = 0;
public static void main(String[] args) throws InterruptedException 【
	List<Thread> list = new ArrayLIst<>();
	for (int j = 0; j < 2; j++) {
		Thread thread = new Thread(() -> {
			for (int k = 0; k < 5000; k++) [
				synchronized (i) {
					i++;
				}
			}
		}, " " + j);
		list.add(thread);
	}
	list.stream().forEach(t -> t.start());
	list.stream().forEach(t  -> {
		try {
			t.join();
		}  catch (InterruptedException e) {
			e.printStackTrace();
		}
	});
思路

image-20250319224455688

  1. 适用 AtomicInteger
  2. 适用显式锁(ReentrantLock)
  3. 使用 synchronized 锁固定对象

答案

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    private static AtomicInteger i = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        List<Thread> list = new ArrayList<>();
        for (int j = 0; j < 2; j++) {
            Thread thread = new Thread(() -> {
                for (int k = 0; k < 5000; k++) {
                    i.incrementAndGet(); // 原子操作
                }
            }, " " + j);
            list.add(thread);
        }
        list.forEach(Thread::start);
        list.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("Final value of i: " + i.get());
    }
}
卖票问题

image-20250319224946924

image-20250319225131382

public class ExerciseSell {
    public static void main(String[] args) {
        TicketWindow ticketWindow = new TicketWindow(2000);
        List<Thread> list = new ArrayList<>();
        // 用来存储买出去多少张票
        List<Integer> sellCount = new Vector<>();
        for (int i = 0; i < 2000; i++) {
            Thread t = new Thread(() -> {
                // 分析这里的竞态条件
                int count = ticketWindow.sell(randomAmount());
                sellCount.add(count);
            });
            list.add(t);
            t.start();
        }
        list.forEach((t) -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 买出去的票求和
        log.debug("selled count:{}", sellCount.stream().mapToInt(c -> c).sum());
        // 剩余票数
        log.debug("remainder count:{}", ticketWindow.getCount());
    }

    // Random 为线程安全
    static Random random = new Random();

    // 随机 1~5
    public static int randomAmount() {
        return random.nextInt(5) + 1;
    }
}

class TicketWindow {
    private int count;

    public TicketWindow(int count) {
        this.count = count;
    }

    public int getCount() {
        return count;
    }

    public int sell(int amount) {
        if (this.count >= amount) {
            this.count -= amount;
            return amount;
        } else {
            return 0;
        }
    }
}

image-20250319225110511

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Vector;

public class ExerciseSell {
    public static void main(String[] args) {
        TicketWindow ticketWindow = new TicketWindow(2000);
        List<Thread> list = new ArrayList<>();
        List<Integer> sellCount = new Vector<>(); // 使用 Vector 确保线程安全

        for (int i = 0; i < 2000; i++) {
            Thread t = new Thread(() -> {
                int count = ticketWindow.sell(randomAmount());
                sellCount.add(count);
            });
            list.add(t);
            t.start();
        }

        list.forEach((t) -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("selled count: " + sellCount.stream().mapToInt(c -> c).sum());
        System.out.println("remainder count: " + ticketWindow.getCount());
    }

    static Random random = new Random();

    public static int randomAmount() {
        return random.nextInt(5) + 1;
    }
}

class TicketWindow {
    private int count;

    public TicketWindow(int count) {
        this.count = count;
    }

    public synchronized int getCount() {
        return count;
    }

    public synchronized int sell(int amount) {
        if (this.count >= amount) {
            this.count -= amount;
            return amount;
        } else {
            return 0;
        }
    }
}
转账练习
public class ExerciseTransfer {
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                a.transfer(b, randomAmount());
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                b.transfer(a, randomAmount());
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        // 查看转账2000次后的总金额
        log.debug("total:{}", (a.getMoney() + b.getMoney()));
    }

    // Random 为线程安全
    static Random random = new Random();

    // 随机 1~100
    public static int randomAmount() {
        return random.nextInt(100) + 1;
    }
}

class Account {
    private int money;

    public Account(int money) {
        this.money = money;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void transfer(Account target, int amount) {
        if (this.money > amount) {
            this.setMoney(this.getMoney() - amount);
            target.setMoney(target.getMoney() + amount);
        }
    }

    }
    这样改正行不行，为什么？

    public synchronized void transfer(Account target, int amount) {
    if (this.money > amount) {
    this.setMoney(this.getMoney() - amount);
    target.setMoney(target.getMoney() + amount);
    }
    }

image-20250319231751711

改进后的代码使用全局锁
import java.util.Random;

public class ExerciseTransfer {
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                a.transfer(b, randomAmount());
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                b.transfer(a, randomAmount());
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("total: " + (a.getMoney() + b.getMoney()));
    }

    static Random random = new Random();

    public static int randomAmount() {
        return random.nextInt(100) + 1;
    }
}

class Account {
    private int money;

    public Account(int money) {
        this.money = money;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void transfer(Account target, int amount) {
        synchronized (Account.class) {
            if (this.money > amount) {
                this.setMoney(this.getMoney() - amount);
                target.setMoney(target.getMoney() + amount);
            }
        }
    }
}
陈逸轩*^_^*
关注
JUC快速入门各个知识点汇总
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
04-07 1917
文章目录前言各类锁汇总相关锁知识点可重入锁与不可重入锁乐观锁与悲观锁自旋锁(含自定义自旋锁)知识补充上下文切换CPU多层缓存架构介绍CPU的三级缓存缓存一致性协议导致的问题一、初识JUC1.1、JUC是什么？1.2、JUC三个包介绍java.util.concurrent包java.util.concurrent.locks包(含两个模板)java.util.concurrent.atomic包1.3、synchronized与lock区别二、生产者消费者问题2.1、synchronized实现2.2、Lo
JUC初阶学习
Ian_IMIL的博客
07-14 437
JUC学习 1、回顾进程线程与并发并行 1、进程与线程 java真的可以开启线程吗？不可以 public synchronized void start() { /** * This method is not invoked for the main method thread or "system" * group threads created/set up by the VM. Any new functionality added * to this meth
JUC学习笔记(一)
zhou22的博客
09-16 2065
文章目录一、进程与线程1.1 进程与线程1）进程2）线程3）二者对比1.2 并行与并发注意二、Java线程2.1 创建和运行线程1）直接使用 Thread2）使用 Runnable 配合 Thread3）FutureTask 配合 Thread2.2 查看进程线程的方法1）windows2）linux3）java2.3 原理之线程运行栈与栈帧线程上下文切换2.4 常见方法2.5 start 与 run2.6 sleep 与 yieldsleepyield线程优先级2.7 join 方法详解为什么需要 jo
多线程进阶复习JUC并发编程
ptGrapes的博客
10-22 536
1、什么是JUC？ JUC指的是全称叫java.util.concurrent包下的工具类。用中文概括一下，JUC的意思就是java并发编程工具包。其下包含三个最常用的并发编程的工具类：java.util.concurrent、java.util.concurrent.atomic、java.util.concurrent.locks。 2、Lock锁 2.1传统的使用synchronized锁的方式 public class JUC { public static void main(Strin
并发编程的艺术（11）：JUC里的工具类介绍
m0_50275872的博客
04-21 1038
JUC
Thread & JUC
kite的博客
05-04 301
线程简介 普通方法调用和多线程 程序、进程、线程 一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等 程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。 线程是CPU调度和执行的的单位。 注意：很...
JUC并发编程
qq_48512649的博客
07-15 192
JUC并发编程
尚硅谷面试(JUC)
qq_40649503的博客
05-07 486
尚硅谷面试(JUC)
深度干货 | 万字长文爆肝JUC，超强学习笔记整理
qq_45832461的博客
08-18 464
史上最全的JUC入门学习笔记，最全面深入的JUC讲解，扫除Java并发编程知识点，直通Java后端面试！
【代码优化技巧】：揭秘减少ConcurrentHashMap锁竞争的高效策略
[【代码优化技巧】：揭秘减少ConcurrentHashMap锁竞争的高效策略](https://img-blog.csdnimg.cn/img_convert/1c56956d20d80179b92340492110d393.png#pic_center) # 1. ConcurrentHashMap简介与基础使用 ## 1.1 ...
【一篇吃透面试八股】——Java并发编程：JUC篇
weixin_43118288的博客
04-10 1212
一篇吃透java面试八股——juc并发编程篇
java基础版
CAIBI0001的博客
03-31 620
java基础 一、 java概述 1.java之父：詹姆斯·高斯林 2.java体系 1、javaSE，标准版，各应用平台的基础，桌面开发和低端商务应用的解决方案。 2、javaEE，企业版，以企业为环境而开发应用程序的解决方案。 3、javaME，微型版，致力于消费产品和嵌入式设备的最佳方案。 3.java特性 1、一种面向对象的编程语言。 2、一种与平台无关的语言（根据JVM实现的）。 3、一种健壮性语言。 4、具有较高的安全性。 4.javac命令和java命令 javac：负责的是编
SSM企业物资管理系统h3109(程序+源码+数据库+调试部署+开发环境)带论文文档1万字以上，文末可获取，系统界面在最后面
2509_93102542的博客
11-21 757
在技术实现上，国外多采用成熟的开发框架和技术架构，注重系统的安全性、稳定性和可扩展性，同时积极融入大数据、人工智能等新技术，实现物资需求预测、智能库存优化等功能。基于此，开发一套基于SSM框架的企业物资管理系统，整合部门、员工、物资及各类业务流程管理功能，实现物资管理的数字化、规范化和高效化，成为解决企业物资管理痛点的必然需求。本课题旨在开发一套基于SSM框架的企业物资管理系统，围绕部门、员工、物资信息、物资申请、消息提醒、物资归还、物资入库、意见反馈八大核心功能模块，实现企业物资管理的全流程数字化。
spring全局懒加载(default-lazy-init)导致的afterPropertiesSet不执行问题
豆豆的博客
11-21 431
Spring配置default-lazy-init="true"会导致所有Bean延迟初始化，影响afterPropertiesSet方法的执行时机。解决方案包括：1)为关键Bean显式设置lazy-init="false"；2)使用@Lazy(false)注解；3)编程式强制初始化；4)使用DependsOn控制顺序。最佳实践建议分层配置策略，核心组件立即初始化，业务组件懒加载，并通过配置文件分离和环境区分优化配置。实际应用中，Web应用的请求处理相关Bean和批处
Java集合框架实战：构建高效的企业管理系统
2402_83075343的博客
11-23 656
本文通过两个企业管理系统案例，详细解析了Java集合框架的核心应用。员工部门管理系统采用HashMap实现部门与员工的高效映射，具备智能添加、快速查询和动态统计功能；商品库存管理系统基于ArrayList实现精细化管控，包含智能录入、库存预警和价格排序等特性。文章对比了HashMap和ArrayList的特性差异，提供了集合选型的最佳实践，并探讨了系统扩展方向。这两个实战案例展示了集合框架在企业应用中的实际价值，为开发者掌握Java集合提供了实用参考。
Spring Boot与MyBatis
2509_94083104的博客
11-23 806
Spring Boot是一个用于创建独立的、基于Spring的生产级应用程序的框架，它简化了Spring应用的初始搭建以及开发过程。MyBatis是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。将Spring Boot和MyBatis结合使用，可以高效地开发数据驱动的应用程序。
failed to parse multipart servlet request
Rockandrollman的博客
11-22 98
failed to parse multipart servlet request
SpringAI的学习以及智能聊天机器人项目
s_x_h_j的博客
11-20 541
本文介绍了SpringAI框架及其在Java开发中的应用
腾讯云-(7)-宝塔面板-安装JDK(外部)
最新发布
weixin_45828554的博客
11-23 109
摘要：本文介绍Java建站需安装JDK1.8的基本要求，暂不限定安装路径，建议先进行尝试。配图展示了JDK安装过程的关键步骤界面，为读者提供直观参考。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值