【面试】Java面试中被问到多线程都不会？

分手后的思念是犯贱 2021-09-02 06:53 383阅读 0赞

> 多线程也是Java面试中非常重要的知识点了，经常被问到，总结一下，为了以后的offer。

![image-20201106160907772][]

### 文章目录 ###

*  1.如何可以创建一个线程的类?
 *  2.说说乐观锁和悲观锁
 *  3.在Java中如何实现多线程同步,通过什么怎样的操作?
 *   *  追问,同步代码块和同步方法实现线程同步有什么异同?
 *  4.sleep()方法和wait()方法有什么异同?
 *  5.线程的生命周期有哪些？以及它们之间的转换？
 *  6.sleep（）方法和yield（）方法区别？
 *   *  拓展：如何实现两个线程A和B，让A一定在B之前运行呢？
 *  7.在多线程编程里，wait方法的调用方式是怎样的？
 *  8.创建n多个线程，如何保证这些线程同时启动？看清，是“同时”。
 *  9.编程中常见的锁对象都有哪些?
 *  10. 线程的种类?
 *   *  追问，什么是守护线程
 *  11.线程的退出方式？
 *  12.手写生产者消费者问题

# 1.如何可以创建一个线程的类? #

继承Thread类（重写run方法）或者实现Runnable接口(实现run方法)或者实现Callable(重写call方法)的方式。

**通过继承Thread的方式实现一个线程**

public class ThreadDemo1{ 
        public static void main(String [] args){ 
            MyThread1 1 = new Thread1();
            t1.start();
        }
    }
    class MyThread1 extends Thread{ 
        public void run(){ 
            //do something
        }
    }

**通过实现Runnable的方式实现一个线程**

public class ThreadDemo2{ 
        public static void main(String [] args){ 
            MyThread2  t2 = new MyThread2();
            Thread t = new Thread(t2);
            t.start();
        }
    }
    class MyThread2{ 
        public void run(){ 
            //do something
        }
    }

**通过实现callable接口来实现一个线程**

这种实现方式与之前的不同是:`该方式可以在实现线程的同时,通过线程产生一个返回值`,而之前的两种方式重写的run()方法是不允许有返回值的。

public class MyTask implements Callable<Integer> { 
        private int upperBounds;
     
        public MyTask(int upperBounds) { 
            this.upperBounds = upperBounds;
        }
     
        @Override
        public Integer call() throws Exception { 
            int sum = 0;
            for(int i = 1; i <= upperBounds; i++) { 
                sum += i;
            }
            return sum;
        }
    }

## 追问,这三种创建线程的方法都有什么特点?

1.  Thread是通过继承的方式,而Runnable是通过实现的方式。
2.  通过继承的方式相对于较为简单，但是由于Java单继承的特性，如果后续的代码需要重构，那么就变的比较困难。

# 2.说说乐观锁和悲观锁 #

悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会 block 直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write\_condition 机制的其实都是提供的乐观锁。

两者并不能说那个锁更好，都有其适合的使用场景。

乐观锁适用于读操作很多，但是写操作比较少的情况（可以提高吞吐量），悲观锁适用于写操作比较多的情况。

# 3.在Java中如何实现多线程同步,通过什么怎样的操作? #

可以通过同步代码块或者同步方法的方式实现多线程同步。

**同步代码块的方式实现线程同步**

public void PlusNum(int num){ 
        synchronized(num){ 
        	//do something(基本实现业务逻辑)
    	}
    }

**同步方法的方法实现线程同步**

public synchronized void SlowNum(int num){ 
        //do something(具体实现业务逻辑)
    }

## 追问,同步代码块和同步方法实现线程同步有什么异同? ##

相同:

都能实现线程同步的需求。

不同：

1.  因为锁的范围不同，因此一般来说只在需要的地方加锁的方式（同步代码块）的执行效率更高
2.  但是由于同步方法的方式将需要同步的业务逻辑部分抽象为了一个方法，因此，如果业务逻辑比较复杂，那么推荐使用同步方法的方式实现线程同步。

# 4.sleep()方法和wait()方法有什么异同? #

1.  sleep()和wait()方法都是让线程暂时停止运行
2.  sleep()是线程Thread的方法,而wait是Object类的方法
3.  sleep()方法执行时虽然当前线程不再继续执行,但是仍然持有对象的锁,而wait()方法执行之后,线程会放弃持有当前对象的锁而进入阻塞队列。
4.  sleep（）方法有重载方法可以传入一个线程等待的毫秒值，在等待时间结束之后，线程恢复运行，而对于wait（）方法只能等执行notify（）方法或者notifyAll（）方法唤醒线程，才能进入到就绪队列。（也就是wait（）方法的执行会让线程进入到线程等待队列中，只有唤醒才能重新进入就绪状态）。

**Wait通常被用于线程间交互，sleep通常被用于暂停执行。**

# 5.线程的生命周期有哪些？以及它们之间的转换？ #

1.  新建状态
2.  就绪状态
3.  阻塞状态
4.  执行状态
5.  销毁状态

![image-20201106150844927][]

*  这里要注意的是调用start（）方法只是让线程进入了就绪状态，也就是该线程是有运行的条件。
 *  而线程真正运行的标志是该线程运行了run（）方法。

# 6.sleep（）方法和yield（）方法区别？ #

sleep方法和yield（）方法都可以让当前线程暂时让出CPU资源，但是二者有很大的不同。

*  sleep方法让线程进入到阻塞队列（不释放当前的锁资源）
 *  yeild（）方法指的是线程让步，让当前线程给别的线程让步，当前的线程不会进入阻塞队列，而是转为就绪状态，给谁让步呢？给优先级更高的线程让步。

## 拓展：如何实现两个线程A和B，让A一定在B之前运行呢？ ##

(如果我没记错的话,\*\*速游今年的一个编程题就是这个不过它是三个线程)

思路：

> 1.  第一种方式,在代码中将执行的顺序写死。
> 2.  第二种方法，使用yeild（）方法，并给A线程设置比B高的优先级，这样在运行时，B就会给A让步
> 3.  第三种方式：使用线程合并的方式：（契合度最高的方法），使用join方法，在线程B执行时，将A线程合并进去，让线程A一定在线程B执行之前执行。

# 7.在多线程编程里，wait方法的调用方式是怎样的？ #

答:wait方法是线程通信的方法之一，必须用在 synchronized方法或者synchronized代码块中，否则会抛出异常，这就涉及到一个“锁”的概念，而wait方法必须使用上锁的对象来调用，从而持有该对象的锁进入线程等待状态，直到使用该上锁的对象调用notify或者notifyAll方法来唤醒之前进入等待的线程，以释放持有的锁。

# 8.创建n多个线程，如何保证这些线程同时启动？看清，是“同时”。 #

答：用一个for循环创建线程对象，同时调用wait()方法，让所有线程等待；直到最后一个线程也准备就绪后，调用notifyAll(), 同时启动所有线程。

比如：给你n个赛车，让他们都在起跑线上就绪后，同时出发，Java多线程如何写代码？

思路是，来一辆赛车就加上一把锁，并修改对应的操作数，如果没有全部就绪就等待，并释放锁，直到最后一辆赛车到场后唤醒所有的赛车线程。

public class CarCompetion { 
        // 参赛赛车的数量
        protected final int totalCarNum = 10;
        // 当前在起跑线的赛车数量
        protected int nowCarNum = 0;
    }

public class Car implements Runnable{ 
        private int carNum;
        private CarCompetion competion = null;
        public Car(int carNum, CarCompetion competion) { 
            this.carNum = carNum;
            this.competion = competion;
        }
        @Override
        public void run() { 
            synchronized (competion) { 
                competion.nowCarNum++;
                while (competion.nowCarNum < competion.totalCarNum) { 
                    try { 
                        competion.wait();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
                competion.notifyAll();
            }
            startCar();
        }
        private void startCar() { 
            System.out.println("Car num " + this.carNum + " start to run.");
            try { 
                Thread.sleep(3000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("Car num " + this.carNum + " get to the finish line.");
        }
    }

# 9.编程中常见的锁对象都有哪些? #

1.  共享资源
2.  this
3.  当前类的字节码文件对象

# 10. 线程的种类? #

线程分为用户线程和守护线程。

## 追问，什么是守护线程 ##

守护线程不属于任何类或者对象，它是在后台做调度工作或者支持性工作。最常见的守护线程就是GC（垃圾回收器线程）。

守护线程的特点就是：不需要我们手动管理，而是自动管理的，当我们程序中有用户线程时，就会自动的启动守护线程，而在我们程序中不存在运行中的用户线程时，这时守护线程也会自动的销毁。

# 11.线程的退出方式？ #

这个题不太高频，但是也是会问到：

1.  等待run（）方法执行结束就会自动退出。
2.  调用System.exit（）方法让系统退出。
3.  也可以使用stop方法或者suspend()方法,但是这两个方法都不推荐使用,可能会造成无法预料的后果。

# 12.手写生产者消费者问题 #

这个问题,我之前在博客中写给比较详细的代码了。

[一个生产者和一个消费者问题][Link 1]

[多个生产者多个消费者问题][Link 2]

![image-20201106161038747][]  
`前文推荐`  
[【备战春招算法篇】数组高频题复习][Link 3]

[【数据库常见面试题】常见面试题以及其基础详解][Link 4]  
[【面试】2021秋招后总结的集合框架的知识我掏出来了（一把辛酸泪）][2021]

[image-20201106160907772]: /images/20210724/1e07c0b27d8d43b99f2a8889b15eae3f.png
[image-20201106150844927]: /images/20210724/54923fcca8ae44fab0b98f11c48c938b.png
[Link 1]: https://blog.csdn.net/qq_40742223/article/details/104691068?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160464950919725266906236%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=160464950919725266906236&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_blog_default-1-104691068.pc_v2_rank_blog_default&utm_term=%E7%94%9F%E4%BA%A7%E8%80%85&spm=1018.2118.3001.4450
[Link 2]: https://blog.csdn.net/qq_40742223/article/details/104694830?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160464950919725266906236%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=160464950919725266906236&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_blog_default-2-104694830.pc_v2_rank_blog_default&utm_term=%E7%94%9F%E4%BA%A7%E8%80%85&spm=1018.2118.3001.4450
[image-20201106161038747]: /images/20210724/8b2f9fc1db6d47798a0603aff26f78b2.png
[Link 3]: https://blog.csdn.net/qq_40742223/article/details/109326275
[Link 4]: https://blog.csdn.net/qq_40742223/article/details/109440466
[2021]: https://blog.csdn.net/qq_40742223/article/details/109522714