标签：me 面试题 Thread synchronized 三道 img 死锁 线程 多线程

> 茫茫人海千千万万，感谢这一秒你看到这里。希望我的面试题系列能对你的有所帮助！共勉！ > > 愿你在未来的日子，保持热爱，奔赴山海！ # 每日三道面试题，成就更好自我 > 今天我们继续聊聊多线程的话题吧！ ## 1. 你知道线程安全问题吗？ 线程安全问题：一般指在多线程模式下，多个线程对同一个共享数据进行操作时，第一个线程还没来得及更新共享数据，从而导致另外一个线程没得到最新的数据，并更新数据，从而产生线程安全问题。比较常见的场景有买票。 我举个例子吧： 需求：比如买周杰伦演唱会的门票，此时有三个窗口同时卖总共100张票。窗口就是线程对象，而100张票的资源，此时就相当于多个线程去抢占cpu的资源去抢对票的使用权。  嘿嘿，这是在大学时期和MyGirl去看滴，现在想去看也没办法了。话不多说，我们还是来看看代码吧： ```java public class SellTicketDemo { public static void main(String[] args) { // 创建线程任务对象 Ticket ticket = new Ticket(); //创建三个窗口对象 Thread thread = new Thread(ticket, "窗口1"); Thread thread2 = new Thread(ticket, "窗口2"); Thread thread3 = new Thread(ticket, "窗口3"); //同时卖票 thread.start(); thread2.start(); thread3.start(); } } // 创建Ticket实现Runnale class Ticket implements Runnable { private int ticket = 100; // 100张周杰伦演唱会门票 // 执行买票的逻辑 @Override public void run() { // 注意每个窗口都有卖票的权利 while (true) { if (ticket > 0) { // 有票 可以卖 // 出票: 因为进来买票，总有出票，总会慢慢没票的吧 try { // 这里采用sleep稍微等待下，模拟一下出票时间 。 Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 获取当前线程对象的名字 System.out.println(Thread.currentThread().getName() + "正在卖:" + ticket--); } } } } ``` 这里讲下： 我们创建了Ticket实现Runnable接口，并重写里面的run方法实现买票的功能，并定义了一个共享的变量。并在main方法中创建了三个线程去实现三个窗口买票的功能。最后我们来看看结果吧： 在你多运行几次，可以看到这样的现象：   1. 卖出了不存在的票，比如0票与-1票，是不存在滴。而且这种情况根本不允许发生呀，谁会卖0张甚至-1张票呢。 2. 出现多卖相同的票数，比如8和1这张票被卖了三回。那这就很过分了呦，一张票还可以卖三个人哈哈。 这些问题的发生就代表我们刚才是线程不安全的了。那线程安全问题具体是什么呢？我们可以总结得到： 是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。 那可能发生线程安全问题的条件： 1. 是否多线程环境下，单线程情况去对数据操作，当然是没什么问题滴啦！ 2. 是否存在共享变量，如上面的代码中，定义了一个全局变量ticket的演唱会门票，多个线程会共享这一变量。 3. 是否存在多条语句操作共享数据，如上面的代码中，你在卖出票后，ticket变量肯定需要减少滴呀，所以对ticket进行了减的操作了。 > 不错呀！那咱们继续来 ## 2. 那如何解决线程安全问题呢？ 我们可以引入线程同步解决线程安全问题。在上面卖票问题中，多线程并发访问一个资源的安全性问题：也就是解决重复票与不存在票问题，Java中提供了同步机制(`synchronized`)来解决。 即具体的解决思路是这样的： 1. 窗口1线程进入买票的时候，窗口2和窗口3线程只能在外等着，此时是不能进行买票的操作的，只能等待窗口1买票完毕后，就进入到窗口1和窗口2和窗口3再次抢占cpu的资源去执行卖票功能。 2. 也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。 而`synchronized` 关键字又给我们提供几种方法呢： 1. 实现同步代码块：`synchronized`关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。 2. 实现同步方法：使用`synchronized`修饰的方法，就叫做同步方法，保证一个线程执行该方法的时候，其他线程只能在方法外等着。 ```java public class SynchronizedDemo { // 加在方法上 实际是对this对象加锁 private synchronized void synchronizedTest() { } // 同步代码块,锁对象可以是任意的，可以使用this，或者类.class对象，或者任意对象都可以 private void synchronizedTest2(){ synchronized (this){ } } // 加在静态方法上 实际是对类对象加锁 private synchronized static void synchronizedTest3() { } } ``` 除了`synchronized` 关键字，还有`Lock` 锁，与此种方法需要自己定义锁的释放位置。 ```java Lock lock = new ReentrantLock(); lock.lock(); // 自己定义开启锁位置 try { System. out. println("我们获得了锁"); } catch (Exception e) { } finally { System. out. println("我们释放了锁"); lock.unlock();// 需要自己定义释放锁位置，不然会存在死锁问题。 } ``` 那我们总结下： 我们怎么保证安全问题： 1. 使用synchronized关键字，实现同步代码块或者同步方法。达到保证一个线程对资源操作的时候，其他线程只能等待。 2. 用手动锁 Lock，使用Lock锁出现的位置可以相对比较灵活，但是必须有释放锁的配合动作。 两者的区别： 1. synchronized 它是Java中的关键字，而Lock是一个类，它是个接口一般我们会使用ReentrantLock来创建实例对象。 2. synchronized 它可以修饰在类、方法、变量中，可以实现同步代码块，而ReentrantLock只适用于代码块锁。 3. synchronized 操作的应该是对象头中 mark word，而ReentrantLock 底层调用的是 Unsafe 的park 方法加锁。 4. ReentrantLock 必须手动获取与释放锁，而synchronized 不需要手动释放和开启锁。 5. 两者都是可重入锁。可重入锁就是**允许同一个线程多次获取同一把锁**，如果某个线程已经获得某个锁，自己可以再次获取锁而不会出现死锁。而如果是不可锁重入的话，就会造成死锁。 > 既然讲到死锁，那问你最后一道： ## 3. 那你讲下死锁是什么吧？ 死锁是指两个或两个以上的进程（线程）在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。 举个例子：你和你女朋友吵架，你们开始互掐头发，你揪着她秀长的长发，而她揪着你寸头，你们俩疼痛不比，但是彼此都是暴脾气，彼此发狠的说你放不放，不放我也不放，看先疼死了！此时你们互相观望着对方，喊着誓不放手。现在就相当产生了死锁现象，互相等待。  我们来简单演示下线程死锁的代码吧： ```java public class DeadlockDemo { public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); new Thread(myRunnable, "看戏观众1看到").start(); new Thread(myRunnable, "看戏观众2看到").start(); } } class MyRunnable implements Runnable { Object me = new Object(); Object myGirl = new Object(); @Override public void run() { synchronized (me) { System.out.println(Thread.currentThread().getName() + "me：我要掐死你！你放不放呀"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "me：你放手我就放手！"); synchronized (myGirl) { System.out.println(Thread.currentThread().getName() + "me：你倒是快放手呀！你不疼吗？"); } } synchronized (myGirl) { System.out.println(Thread.currentThread().getName() + "myGirl：老娘我才要掐死你！你还不放？你今晚谁地板吧！"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "myGirl：是你放手才对！"); synchronized (me) {// t1 , objB, 拿不到A锁,等待 System.out.println(Thread.currentThread().getName() + "myGirl：看来你今晚要睡地板啊"); } } } } ``` 先看看结果：  首先可以看到我们的进程还在运行状态，但是都不往下运行代码了，为什么呢，我们来分析来： 此时的状态是线程1在执行第二个synchronized (myGirl) 这个同步代码块里中，还在等待me放手的时候，此时线程2又进来了，执行了第一个synchronized (me)这一个同步代码块中，相当于把me这个锁锁住了。 而线程1此时想进入第二个synchronized (me)的时候，发现这个me的锁被人拿了就陷入等待状态，而线程2发现要进入到第一个synchronized (myGirl) 中，myGirl又被线程1拿住了，也陷入了等待状态。此时状态就是两个人在互相等待对方结束释放锁，陷入了无限等待的状态。 而产生死锁的必要条件有： 两个或两个以上的线程在执行过程中，因争夺资源而造成了互相等待的状态。 1. 互斥条件：线程对于所分配到的资源具有排它性，即一个资源只能被一个线程占用，直到被该线程(进程)释放。 2. 请求与保持条件：一个线程因请求被占用资源而发生阻塞时，对已获得的资源保持不放，即一个线程在已经有一个资源的资格后，又提出了新的资源请求。 3. 不剥夺条件：线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。 4. 循环等待条件：当发生死锁时，所等待的线程必定会形成一个资源的环形链（类似于死循环），造成永久阻塞。 > 小伙子不错嘛！今天就到这里，期待你明天的到来，希望能让我继续保持惊喜！ 注: 如果文章有任何错误和建议，请各位大佬尽情留言！如果这篇文章对你也有所帮助，希望可爱亲切的您给个三连关注下，非常感谢啦！ 

标签：me,面试题,Thread,synchronized,三道,img,死锁,线程,多线程
来源： https://blog.51cto.com/u_15285596/3006665

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。