面试题收集（五）

最新推荐文章于 2023-12-26 15:03:48 发布

漫玥刚花

最新推荐文章于 2023-12-26 15:03:48 发布

阅读量1.3k

点赞数

分类专栏：面-试-题

本文链接：https://blog.csdn.net/gangsijay888/article/details/88858076

版权

面-试-题专栏收录该内容

58 篇文章 2 订阅

订阅专栏

1、1. junit用法，before,beforeClass,after, afterClass的执行顺序

2、分布式锁

3、nginx的请求转发算法，如何配置根据权重转发

4、用hashmap实现redis有什么问题

5、线程状态

6、为什么notify(), wait()等函数定义在Object中，而不是Thread中

7、yield()介绍

8、 yield() 与 wait()的比较

9、sleep()介绍，sleep() 与 wait()的比较

10、一万个人抢100个红包，如何实现（不用队列），如何保证2个人不能抢到同一个红包，可用分布式锁

11、两个Integer的引用对象传给一个swap方法在方法内部交换引用，返回后，两个引用的值是否会发现变化

1、1. junit用法，before,beforeClass,after, afterClass的执行顺序

@BeforeClass -> @Before -> @Test -> @After -> @AfterClass;

2、分布式锁

https://blog.csdn.net/gangsijay888/article/details/81213945

3、nginx的请求转发算法，如何配置根据权重转发

请求转发算法：

1）轮询（默认的负载均衡方式）

轮询：依次将请求分配到各个后台服务器中，适用于后台机器性能一致的情况。挂掉的机器可以自动从服务列表中剔除。

2）权重（weight）

权重：根据权重来分发请求到不同的机器中，指定轮询几率，weight和访问比率成正比，用于后端服务器性能不均的情况。

upstream bakend {
server 192.168.0.14 weight=10;
server 192.168.0.15 weight=10;
}

3）ip hash（解决session问题）

根据请求者ip的hash值将请求发送到后台服务器中，可以保证来自同一ip的请求被打到固定的机器上，可以解决session问题。

upstream bakend {
ip_hash;
server 192.168.0.14:88;
server 192.168.0.15:80;
}

4）url hash(同一台服务器)

根据请求的url的hash值将请求分到不同的机器中，当后台服务器为缓存的时候效率高。

例如：
在upstream中加入hash语句，server语句中不能写入weight等其他的参数，hash_method是使用的hash算法
upstream backend {
server squid1:3128;
server squid2:3128;
hash $request_uri;
hash_method crc32;
}

tips:
upstream bakend{#定义负载均衡设备的Ip及设备状态
ip_hash;
server 127.0.0.1:9090 down;
server 127.0.0.1:8080 weight=2;
server 127.0.0.1:6060;
server 127.0.0.1:7070 backup;
}

在需要使用负载均衡的server中增加
proxy_pass http://bakend/;
每个设备的状态设置为:
1.down 表示单前的server暂时不参与负载
2.weight 默认为1.weight越大，负载的权重就越大。
3.max_fails ：允许请求失败的次数默认为1.当超过最大次数时，返回proxy_next_upstream 模块定义的错误
4.fail_timeout:max_fails次失败后，暂停的时间。
5.backup：其它所有的非backup机器down或者忙的时候，请求backup机器。所以这台机器压力会最轻。
nginx支持同时设置多组的负载均衡，用来给不用的server来使用。
client_body_in_file_only 设置为On 可以讲client post过来的数据记录到文件中用来做debug
client_body_temp_path 设置记录文件的目录可以设置最多3层目录
location 对URL进行匹配.可以进行重定向或者进行新的代理负载均衡

5）fair （服务器响应时间短的，优先分配）

upstream backend {
server server1;
server server2;
fair;
}

4、用hashmap实现redis有什么问题

（线程安全问题，可用ConcurrentHashmap）

5、线程状态

线程共包括以下5种状态。
1. 新建状态(New) : 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。
3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。
4. 阻塞状态(Blocked) : 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
(01) 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。
(02) 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
(03) 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5. 死亡状态(Dead) : 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

6、为什么notify(), wait()等函数定义在Object中，而不是Thread中

Object中的wait(), notify()等函数，和synchronized一样，会对“对象的同步锁”进行操作。

wait()会使“当前线程”等待，因为线程进入等待状态，所以线程应该释放它锁持有的“同步锁”，否则其它线程获取不到该“同步锁”而无法运行！
OK，线程调用wait()之后，会释放它锁持有的“同步锁”；而且，根据前面的介绍，我们知道：等待线程可以被notify()或notifyAll()唤醒。现在，请思考一个问题：notify()是依据什么唤醒等待线程的？或者说，wait()等待线程和notify()之间是通过什么关联起来的？答案是：依据“对象的同步锁”。

负责唤醒等待线程的那个线程(我们称为“唤醒线程”)，它只有在获取“该对象的同步锁”(这里的同步锁必须和等待线程的同步锁是同一个)，并且调用notify()或notifyAll()方法之后，才能唤醒等待线程。虽然，等待线程被唤醒；但是，它不能立刻执行，因为唤醒线程还持有“该对象的同步锁”。必须等到唤醒线程释放了“对象的同步锁”之后，等待线程才能获取到“对象的同步锁”进而继续运行。

总之，notify(), wait()依赖于“同步锁”，而“同步锁”是对象锁持有，并且每个对象有且仅有一个！这就是为什么notify(), wait()等函数定义在Object类，而不是Thread类中的原因。

7、yield()介绍

yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！

8、 yield() 与 wait()的比较

我们知道，wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时，也会释放同步锁。而yield()的作用是让步，它也会让当前线程离开“运行状态”。它们的区别是：
(01) wait()是让线程由“运行状态”进入到“等待(阻塞)状态”，而不yield()是让线程由“运行状态”进入到“就绪状态”。
(02) wait()是会线程释放它所持有对象的同步锁，而yield()方法不会释放锁。

// YieldLockTest.java 的源码
public class YieldLockTest{ 

    private static Object obj = new Object();

    public static void main(String[] args){ 
        ThreadA t1 = new ThreadA("t1"); 
        ThreadA t2 = new ThreadA("t2"); 
        t1.start(); 
        t2.start();
    } 

    static class ThreadA extends Thread{
        public ThreadA(String name){ 
            super(name); 
        } 
        public void run(){ 
            // 获取obj对象的同步锁
            synchronized (obj) {
                for(int i=0; i <10; i++){ 
                    System.out.printf("%s [%d]:%d\n", this.getName(), this.getPriority(), i); 
                    // i整除4时，调用yield
                    if (i%4 == 0)
                        Thread.yield();
                }
            }
        } 
    } 
}

结果：
t1 [5]:0
t1 [5]:1
t1 [5]:2
t1 [5]:3
t1 [5]:4
t1 [5]:5
t1 [5]:6
t1 [5]:7
t1 [5]:8
t1 [5]:9
t2 [5]:0
t2 [5]:1
t2 [5]:2
t2 [5]:3
t2 [5]:4
t2 [5]:5
t2 [5]:6
t2 [5]:7
t2 [5]:8
t2 [5]:9

结果说明：
主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁，即synchronized(obj)。在t1运行过程中，虽然它会调用Thread.yield()；但是，t2是不会获取cpu执行权的。因为，t1并没有释放“obj所持有的同步锁”！

9、sleep()介绍，sleep() 与 wait()的比较

我们知道，wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时，也会释放同步锁。而sleep()的作用是也是让当前线程由“运行状态”进入到“休眠(阻塞)状态”。
但是，wait()会释放对象的同步锁，而sleep()则不会释放锁。
下面通过示例演示sleep()是不会释放锁的。

// SleepLockTest.java的源码
public class SleepLockTest{ 

    private static Object obj = new Object();

    public static void main(String[] args){ 
        ThreadA t1 = new ThreadA("t1"); 
        ThreadA t2 = new ThreadA("t2"); 
        t1.start(); 
        t2.start();
    } 

    static class ThreadA extends Thread{
        public ThreadA(String name){ 
            super(name); 
        } 
        public void run(){ 
            // 获取obj对象的同步锁
            synchronized (obj) {
                try {
                    for(int i=0; i <10; i++){ 
                        System.out.printf("%s: %d\n", this.getName(), i); 
                        // i能被4整除时，休眠100毫秒
                        if (i%4 == 0)
                            Thread.sleep(100);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } 
    } 
}

主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁，即synchronized(obj)。在t1运行过程中，虽然它会调用Thread.sleep(100)；但是，t2是不会获取cpu执行权的。因为，t1并没有释放“obj所持有的同步锁”！
注意，若我们注释掉synchronized (obj)后再次执行该程序，t1和t2是可以相互切换的。

10、一万个人抢100个红包，如何实现（不用队列），如何保证2个人不能抢到同一个红包，可用分布式锁

11、两个Integer的引用对象传给一个swap方法在方法内部交换引用，返回后，两个引用的值是否会发现变化

java中是没有指针的，java中只存在值传递，只存在值传递！！！

值传递：

public class Test3 {
    public static void change(int a){
        a=50;
    }
    public static void main(String[] args) {
        int a=10;
        System.out.println(a);
        change(a);
        System.out.println(a);
    }
}

很显然输出的是10，10。传递的是值得一份拷贝，这份拷贝与原来的值没什么关系。

内存分析：

public class testOne327 {

	public static void main(String[] args) {
		Integer a = 1;
		Integer b = 2;
		swap(a,b);
		System.out.println("a="+a);
		System.out.println("b="+b);
		//这里交换
		Integer temp = a;
		a = b;
		b = temp;
		System.out.println("a="+a);
		System.out.println("b="+b);
		
	}
	
	public static void swap(Integer i, Integer j) {
		Integer temp = i;
		i = j;
		j = temp;
	}

}

结果：

a=1
b=2
a=2
b=1

实际上只是分别把a,b的引用值传递给了i,j，i和j实现交换的只是a，b对应的引用值（地址），但是a，b指向的内存的值根本都没有发生变化。所以没有产生任何变化，但是再main方法里面就是在交换ab的实际内存存储的值了。

引用值传递

public class Test3 {
    public static void change(int []a){
        a[0]=50;
    }
    public static void main(String[] args) {
        int []a={10,20};
        System.out.println(a[0]);
        change(a);
        System.out.println(a[0]);
    }
}

显然输出结果为10 50。实际传递的是引用的地址值。

内存分析：

class Emp {
    public int age;
}
public class Test {
    public static void change(Emp emp)
    {
        emp.age = 50;
        emp = new Emp();//再创建一个对象
        emp.age=100;
    }
    
    public static void main(String[] args) {
        Emp emp = new Emp();
        emp.age = 100;
        System.out.println(emp.age);
        change(emp);
        System.out.println(emp.age);
        System.out.println(emp.age);
    }
}

输出为：100 50 50.

内存分析：

对于String类

public class Test {
    public static void change(String s){
        s="zhangsan";
    }
    
    public static void main(String[] args) {
        String s=new String("lisi");
        System.out.println(s);
        change(s);
        System.out.println(s);
    }
}

输出为：lisi lisi，由于String类是final修饰的，不可变，它会在内存中在开辟一块新空间。

12、是否用过maven install、mvn clean package、mvn clean install、mvn clean deploy

maven install是安装本地jar包

mvn clean package依次执行了clean、resources、compile、testResources、testCompile、test、jar(打包)等７个阶段。
mvn clean install依次执行了clean、resources、compile、testResources、testCompile、test、jar(打包)、install等8个阶段。
mvn clean deploy依次执行了clean、resources、compile、testResources、testCompile、test、jar(打包)、install、deploy等９个阶段。
由上面的分析可知主要区别如下，
package命令完成了项目编译、单元测试、打包功能，但没有把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库和远程maven私服仓库
install命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库，但没有布署到远程maven私服仓库
deploy命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库和远程maven私服仓库　　

13、tomcat的各种配置，如何配置docBase

https://blog.csdn.net/gangsijay888/article/details/88858814

14、spring的bean配置的几种方式

https://www.cnblogs.com/mfrank/p/7886958.html

一、基于XML的配置

<bean id=“loginUserDao” class=“com.chinalife.dao.impl.LoginUserDaoImpl”  
        lazy-init=“true” init-method=“myInit” destroy-method=“myDestroy”  
        scope=“prototype”>  
        ……   
</bean>

二、基于注解的配置

@Scope(“prototype”)
@Lazy(true)
@Component(“loginUserDao”)
public class LoginUserDao {
……
// 用于设置初始化方法
@PostConstruct
public void myInit() {

}

// 用于设置销毁方法
@PreDestroy
public void myDestroy() {
}
}

三、基于Java类配置

@Configuration
public class Conf {
@Scope(“prototype”)
@Bean(“loginUserDao”)
public LoginUserDao loginUserDao() {
return new LoginUserDao();
}
}

三种方式的比较：

15、spring的监听器

Spring常用的监听器及作用

https://chenjumin.iteye.com/blog/2249833

SpringMVC中各种监听器的作用

https://blog.csdn.net/feifuzeng/article/details/77851730

监听器的作用：监听器是一个实现特定接口的普通java程序，这个程序专门用于监听另一个java对象的方法调用或者属性改变，当被监听对象发生上述事件后，监听器某个方法将立即执行。

被监听对象→对象拥有的事件→捕获到事件变化→监听器捕捉事件→监听器处理该事件

Spring中org.springframework.web.context.ContextLoaderListener类监听器也是实现了ServletContextListener这个接口。作用是加载了spring的配置文件

16、zookeeper的实现机制，有缓存，如何存储注册服务的

ZooKeeper所提供的服务主要是通过：数据结构+原语+watcher机制

自己链接：https://blog.csdn.net/gangsijay888/article/details/82426068

17、IO会阻塞吗？readLine是不是阻塞的

https://www.cnblogs.com/GrimMjxCl/p/9425174.html

18、BIO（阻塞IO）、NIO（非阻塞同步IO）、AIO（非阻塞异步IO）

https://blog.csdn.net/gangsijay888/article/details/88903834

19、

20、

21、

22、

23、

24、

25、

26、

27、

28、

29、

30、

31、

32、

33、

34、

35、

36、

漫玥刚花

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
面试题收集（五）

目录1、1. junit用法，before,beforeClass,after, afterClass的执行顺序2、分布式锁3、nginx的请求转发算法，如何配置根据权重转发4、用hashmap实现redis有什么问题5、线程状态6、为什么notify(), wait()等函数定义在Object中，而不是Thread中7、yield()介绍8、 yield() 与 ...
复制链接

扫一扫