java面经自用4

最新推荐文章于 2024-05-03 10:00:19 发布
最新推荐文章于 2024-05-03 10:00:19 发布
阅读量264 收藏
点赞数
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Dhxy1030/article/details/120729402
版权
本文探讨了Java中`synchronized`关键字和ReentrantLock API的区别，包括锁的获取释放机制、中断性、公平性以及条件变量的使用示例。还介绍了线程池的创建、常用类型及其参数配置，以及死锁的原理和自定义线程池的示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

java面经自用4

  1. synchronized和lock有什么区别？

    • synchronized是关键字，jvm层面支持，lock是api层面的锁
    • synchronized不需要手动释放，lock需要手动释放不然会死锁(lock(),unlock()方法需要配合try/finally使用)
    • synchronized不可中断，lock可中断(设置超时trylock(Long timeout,TimeUnit unit),调用interrupt可中断
    ReentrantLock lock = new ReentrantLock();
//获取锁
lock.lockInterruptibly();
//中断
new Thread().interrupt();
    • synchronized是不公平锁，lock两者都可以实现boolean为true公平
    • synchronized要么随机唤醒一个要么全部唤醒，lock有条件的唤醒利用condition
    class bean {

    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    public void print(int number) {
        lock.lock();
        if (number == 1) {
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + "==" + i);
            }
            c2.signal();
            try {
                c3.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        if (number == 2) {
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + "==" + i);
            }
            c3.signal();
            try {
                c1.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        if (number == 3) {
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + "==" + i);
            }
            c1.signal();
            try {
                c2.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


public class condition {
    public static void main(String[] args) {
        bean b = new bean();

        new Thread("A") {
            @Override
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    b.print(1);
                }
            }
        }.start();
        new Thread("B") {
            @Override
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    b.print(2);
                }
            }
        }.start();
        new Thread("C") {
            @Override
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    b.print(3);
                }
            }
        }.start();
    }

  2. 线程池

    创建线程4种方式

    为什么出现Callable接口?

    Callable接口(带返回值的)，适合并发，解决阻塞绕过执行时间长的线程

    class myth implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        //只会调用一次，没必要重复执行
        System.out.println(Thread.currentThread().getName()+"====="+"我叼你妈的");
        return 1024;
    }
}

public class mythread {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<>(new myth());
        FutureTask<Integer> task2 = new FutureTask<>(new myth());
        new Thread(task, "AA").start();
        new Thread(task, "BB").start();
		int result01=100;
        int result02=task.get();//建议放在最后使用，也就是说计算完成之后再去调用。如果想提前调用可能会出现自旋，while(!task.idDone)一直判断
        System.out.println(result01+result02);
    }
}

    5种线程池，常用的有三种

    newWorkStealingPool()，java8新推出

    newScheduledThreadPool()带调度的，每隔时间段执行

    newSingleThreadExecutor()一个任务一个任务执行

    newCachedThreadPool()带缓存的，适合执行短期任务，灵活回收线程

    newFixedThreadPool(int),固定数线程，执行长期任务执行性能好

    都是通过new ThreadPoolExecutor()实现

     public static void main(String[] args) {
        ExecutorService pool1 = Executors.newFixedThreadPool(5);//一池五个线程
        ExecutorService pool2 = Executors.newSingleThreadExecutor();//一池一个线程
        ExecutorService pool3 = Executors.newCachedThreadPool();//一池N个线程
        try {
            for (int i = 1; i <= 10; i++) {
//                pool1.execute(new Thread() {
//                    @Override
//                    public void run() {
//                        System.out.println();
//                    }
//                });
                pool1.execute(() -> {
//                只有五个线程去执行
                    System.out.println(Thread.currentThread().getName()+"执行业务");
                });
                pool3.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"执行业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            pool1.shutdown();
        }
    }

    七大参数：

    • int corePoolSize:线程池中的常驻核心线程数
    • int maximumPoolSize：线程池能够容纳同时执行的最大线程数
    • Long KeepAliveTime：多余的空闲线程的存活时间，当线程池数量超过corePoolSize时，当空闲时间达到KeepAliveTime时，多余的空闲线程会被回收到只剩下corePoolSize
    • TimeUnit unit：KeepAliveTime的时间单位
    • BlockingQueue workQueue 任务队列，被提交暂未执行的任务
    • ThreadFactory threadFactory 表示生成线程池中工作线程的线程工厂，用于创建线程
    • RejectedExecutionHandler handler 拒绝策略，表示当队列满了并且工作线程大于等于线程池的最大线程数

    在这里插入图片描述

    4中拒绝策略：

    AbortPolicy：直接抛出RejectedExecutionHandler异常，阻止系统正常运行

    CallerRunsPolicy：将某些任务回退到调用者(main )

    DiscardOldestPolicy:抛弃队列中等待最久的任务，把当前任务加入到队列中并尝试再次提交当前任务

    DiscardPolicy：直接丢弃任务，无不给予任何处理也不抛出异常

    以上策略均实现RejectedExecutionHandler接口,以上线程池在实际开发中并不会使用而是我们自定义线程池

  3. 自定义线程池

    ThreadPoolExecutor pool = new ThreadPoolExecutor(
        2, 5, 1L, TimeUnit.SECONDS,
        new LinkedBlockingQueue<Runnable>(3),
        Executors.defaultThreadFactory(),
        new ThreadPoolExecutor.AbortPolicy()
);
//核心线程数为2，同时运行的最大线程数5(包括核心线程数),空闲队列的生存时间，时间的单位，创建线程的工厂，拒绝策略的设置
 public static void main(String[] args) {

        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                2, 5, 1L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        try {
            for (int i = 1; i <= 10; i++) {
//                pool1.execute(new Thread() {
//                    @Override
//                    public void run() {
//                        System.out.println();
//                    }
//                });
//                最大线程池为5+3=8，但是10个请求则报错
                pool.execute(() -> {
//                只有五个线程去执行
                    System.out.println(Thread.currentThread().getName()+"执行业务");
                });

            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            pool.shutdown();
        }
    }

  4. 如何配置合理线程数

    按照业务进行选择：CPU密集型，IO密集型

    首先调用Runtime.getRuntime().availableProcessors()后

    CPU密集型：

    线程数=CPU核数+1

    IO密集型分两种情况

    • 由于Io密集型任务线程并不是一直在运行任务，则配置尽可能多的线程,线程数= CPU核数*2
    • 线程数=CPU核数/1-阻塞系数，阻塞系数在0.8-0.9

  5. 产生死锁的主要原因？

    指两个或以上的进程在执行过程中，因为争夺资源而造成的一种互相等待的现象，若无外力干涉则永远推进下去，如果系统资源充足，进程的资源都本分得到满足，死锁出现的可能性就很低，否则就会因为争夺资源而陷入死锁

    手写死锁：

    class lock implements Runnable {

    private String lockA;
    private String lockB;

    public lock(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }


    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName()+"持有"+lockA+"尝试获取"+lockB);
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"持有"+lockB+"尝试获取"+lockA);
            }
        }
    }
}


public class dieLock {

    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        new Thread(new lock(lockA, lockB), "ThreadAAA").start();
        new Thread(new lock(lockB, lockA), "ThreadBBB").start();
    }
}
 public class   dieLock {

    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        new Thread(new lock(lockA, lockB), "ThreadAAA").start();
        new Thread(new lock(lockB, lockA), "ThreadBBB").start();
    }
}

    ``
    在这里插入图片描述

2021年Java面试总结题
mzl_sx的博客
11-02 1068
上面的配置前者是3000，后者是500，一旦触发超时降级，就不会重试，hystrix的超时是最高优先级，如果在重试期间，时间超过了hystrix的超时时间，会立即熔断。对于spu\sku、类目等概念比较清楚，但是对于高并发情况下如何支撑大流量没有太多经验，对于缓存的一致性处理、expiretime实现机制等了解不多，服务治理不清楚，zk相关基础比较弱，mysql索引有一定了解。其中对称加密算法的加密与解密 密钥相同，非对称加密算法的加密密钥与解密 密钥不同，此外，还有一类 不需要密钥 的 散列算法。
[Java后端面经]-自用牛客大中小厂一面二面三面实习or正式批-
XYC的学习经验博客
09-13 6851
后端开发面经
java面经自用3
winkooxx
10-10 294
java面经自用2
winkooxx
10-09 176
Java面经自用
winkooxx
10-09 241
Java面经 java中有哪些集合？ 安全：Vector，HashTable，ConcurrentHashMap 非安全：ArrayList，LinkedList，HashMap，TreeMap，HashSet，TreeSet HashMap底层实现及扩容 底层：通过数组+链表+红黑树实现，初始容量是16，加载因子是0.75（超过16*0.75时扩容），加载因子过小会造成浪费，过大会使put，get碰撞几率增加，链表长度超过8时，链表就会转换为红黑树以提高检索速度，提高并发性能 Concurre
Java面经自用5
winkooxx
10-24 270
Java面经自用5 java如何开启线程？怎么保证线程安全？ 线程和进程的区别：进程是操作系统进行资源分配的最小单元。线程是操作系统进行任务分配的最小单元，线程隶属于进程 如何开启线程？ 1.继承Thread，重写run方法 2.实现Runnable接口，重写run方法 3.实现Callable接口，实现call方法。通过FutureTask创建一个线程，获取到线程执行的返回值 class myth implements Callable<Integer> { @Override
Redis秋招面经（自用）
的博客
10-05 824
Redis秋招面经一、Redis是什么Redis优势Redis适用场景Redis很快的原因单线程的原因Redis为什么比MySQL快二、Redis数据类型、各种类型的底层实现及适用场景五大对象三、redis的持久化机制为什么Redis需要持久化？持久化机制RDB（默认）AOF四、缓存雪崩、缓存穿透、缓存预热、缓存更新、缓存降级等问题缓存雪崩缓存穿透缓存预热缓存更新缓存降级五、Redis-skiplist跳表原理六、Redis过期策略、内存淘汰机制Redis的淘汰策略Redis的删除策略七、Redis集群方案
2022面经（自用）
HyzKey2U的博客
05-20 232
1.航天宏图（25分钟） 自我介绍 项目介绍 mysql事务隔离级别 mysql索引 redis用在了哪里 redis雪崩、击穿、穿透 布隆过滤器 接口和抽象类的区别 项目哪里用了接口，哪里用了继承。 谈谈IOC和AOP 2.万得（35分钟） 自我介绍 项目介绍 redis用到了哪里 redis穿透 布隆过滤器 创建线程的方式 直接调用run方法和start调用run方法的区别 start之后线程的状态(等待队列) mysql优化做了哪些 主从复制怎么实现的，延迟怎
面经（自用 不定时更新）
weixin_43766957的博客
06-13 296
go 面经
【基础1.0】自用整理JAVA面试基础知识
teavamc的博客
03-22 2643
鸣谢：感谢JavaGuide-master提供的复习蓝图 1. 面向对象和面向过程的区别 面向过程 优点： 性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。 缺点： 没有面向对象易维护、易复用、易扩展 面向对象 优点： 易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计...
Hadoop+Spark大数据技术（微课版）曾国荪、曹洁版思维导图第一章 Hadoop大数据开发环境（整理复习自用
2401_84165953的博客
05-03 221
里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**
c++面试知识整理
牵LV小猪精的博客
06-13 5057
C++面试题1. 基础知识1.1 内存1.1.0 内存四区1.1.1 简述C、C++程序编译的内存分配情况1.1.2 分配函数与释放函数1.2 预编译1.2.1 头文件问题1.2.2 const 与 #define相比有什么优点1.3 宏，内联函数1.3.1 内联函数1.3.2 内联函数与宏的差别1.3.3 写一个 “标准”宏MIN1.3.4 typedef 和define 有什么区别1.4 指针1.4.1 指针常量和常量指针1.4.2 指针函数和函数指针1.4.3 指针数组数组指针1.4.4 函数传参1.
mybatis注解开发配置及注意事项
winkooxx
06-15 1770
mybatis注解开发配置及注意事项 1.注解及配置： 注解： @Insert:实现新增 @Update:实现更新 @Delete:实现删除 @Select:实现查询 @Result:实现结果集封装 @Results:可以与@Result 一起使用，封装多个结果集 @ResultMap:实现引用@Results 定义的封装 @One:实现一对一结果集封装 @Many:实现一对多结果集封装 @SelectProvider: 实现动态 SQL 映射 @CacheNamespace:实现注解二级缓存的使用 在m
springboot+mybatisplus+vue+elementui前后端分离
winkooxx
07-11 1180
前后端分离 前后端分离就是将⼀个应⽤的前端代码和后端代码分开写，为什么要这样做？ 如果不使⽤前后端分离的⽅式，会有哪些问题？ 传统的 Java Web 开发中，前端使⽤ JSP 开发，JSP 不是由后端开发者来独⽴完成的。前端—》HTML 静态⻚⾯ —〉后端 —》JSP 这种开发⽅式效率极低，可以使⽤前后端分离的⽅式进⾏开发，就可以完美地解决这⼀问题。 前端只需要独⽴编写客户端代码，后端也只需要独⽴编写服务端代码提供数据接⼝即可。 前端通过 Ajax 请求来访问后端的数据接⼝，将 Model
JAVA之多线程
winkooxx
08-20 452
JAVA之多线程 并发与并行 并发（concurrency）和并行（parallellism）是： 解释一：并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。 解释二：并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。 解释三：并行是在一台处理器上“同时”处理多个任务，并发是在多台处理器上同时处理多个任务。如 hadoop 分布式集群。 并行：是逻辑上同时发生，指在某一个时间内同时运行多个程序。 并发：是物理上同时发生，指在某一个时间点同时运行多个程序。
Vue入门学习
winkooxx
06-26 413
Vue入门学习 Vue基础指令与案例演示 1.v-text与v-html v-text只会发数据渲染到标签，不会对html标签进行解析、 v-html会对html标签进行解析 <div id="box"> <!-- vue的指令：vue提供的一种行间属性，你可以加在标签上，对这个DOM元素应用一些行为。 --> <h1>{{msg}}</h1> <!-- v-text 把数据渲染到标签 --> <h1 v-text="
MybatisPlus实例
winkooxx
06-05 386
mp配置 <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.1.0</version> </dependency> spring.datasource.username=root spring.datasource.pas.
并发锁的学习
winkooxx
10-09 374
锁 锁的定义 锁是用来协调多个线程并发访问同一共享资源时带来的安全问题，频繁用锁必然会带来性能问题，但不用锁又会造成安全问题 1）从性能上分：乐观锁和悲观锁 乐观锁：CAS自旋锁，是非常经典的乐观锁，并发性能比较好，但是自旋会造成很大的开销，悲观的认为当前环境下并发情况不是很很严重，任务提交时才才判断是否冲突 悲观锁：悲观的认为当前环境下并发情况是很严重的，所有的任务在执行时都要加上锁，保证了安全型，失去了并发性，并发性能差 乐观锁：无锁，在数据提交时才去判断是否发生冲突，version 悲观锁：每
Spring5学习1
winkooxx
05-05 368
Spring5学习1 Spring set注入 普通值注入 value bean注入 ref 数组 <property name="" > ​ <array> ​ <value></value> ​ <value></value> ​ </array> ​ </property> 集合 <property name="" >
Java面经
最新发布
03-28
- 发布前进行全面质量保障活动直至达到预期目标再迁移到生产环境中运行[^4]。 ```python # 示例代码展示如何创建一个简单的线程 import threading def worker(): """thread worker function""" print('Worker')...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值