java面试题(下)

Posted 2021-01-27 ws563573095

1、多个线程访问同一资源时如何保证线程之间访问的顺序性。

a、方案一

 1 package com.xiyao.opensource.java.lang;
 2 
 3 public class ThreadT {
 4 
 5     /**
 6      * 1、volatile修改，保持signal在多线程之间的可见性
 7      * 2、对象监视器就像是一个绳子，使用这个监视器的都是一条绳上的蚂蚱
 8      * 3、为了保持一直活动下去，一个蚂蚱休息前一定要唤醒别的至少一个蚂蚱
 9      */
10     volatile static Object signal = new Object();
11     
12     public static void main(String[] args) {
13         Thread thread = new Thread() {
14             @Override
15             public void run() {
16                 while(true) {
17                     try {
18                         Thread.sleep(1000L);
19                             /**
20                              * 1、notify和wait必须使用在synchronized中
21                              * 2、他们都是操作对象监视器,synchronized指明了对象监视器对象
22                              */
23                             synchronized(signal) {
24                                 System.out.println(Thread.currentThread().getName()+" 我执行完了!");
25                                 signal.notify();
26                                 signal.wait();
27                             }
28                     } catch (InterruptedException e) {
29                         e.printStackTrace();
30                     }
31                 }
32             }
33             
34         };
35         thread.start();
36         while(true) {
37             try {
38                 Thread.sleep(1000L);
39                     synchronized(signal) {
40                         System.out.println(Thread.currentThread().getName()+" 我执行完了!");
41                         signal.notify();
42                         signal.wait();
43                     }
44             } catch (InterruptedException e) {
45                 e.printStackTrace();
46             }
47         }
48     }
49     50 }

方案二

 1 package com.xiyao.opensource.java.util.concurrent;
 2 
 3 import java.util.concurrent.locks.Condition;
 4 import java.util.concurrent.locks.Lock;
 5 import java.util.concurrent.locks.ReentrantLock;
 6 
 7 public class LockT {
 8 
 9     public static void main(String[] args) {
10         Lock lock = new ReentrantLock();
11         //派生出多个条件(每个都是一个信号量)
12         Condition signalOne = lock.newCondition();
13         Condition signalTwo = lock.newCondition();
14         Thread thread = new Thread() {
15             @Override
16             public void run() {
17                 while(true) {
18                     try {
19                         //抢占对象监视器
20                         lock.lock();
21                         Thread.sleep(1000L);
22                         System.out.println(Thread.currentThread().getName()+" 我执行完了!");
23                         signalOne.signal();
24                         signalTwo.await();
25                     } catch (InterruptedException e) {
26                         e.printStackTrace();
27                     }finally {
28                         lock.unlock();
29                     }
30                 }
31             }
32             
33         };
34         thread.start();
35         while(true) {
36             try {
37                 lock.lock();
38                 Thread.sleep(1000L);
39                 System.out.println(Thread.currentThread().getName()+" 我执行完了!");
40                 signalTwo.signal();
41                 signalOne.await();
42             } catch (InterruptedException e) {
43                 e.printStackTrace();
44             }finally {
45                 lock.unlock();
46             }
47         }
48     }
49 }

方案三

 1 package com.xiyao.opensource.java.util.concurrent;
 2 
 3 import java.util.concurrent.SynchronousQueue;
 4 
 5 public class BlockingQueueT {
 6 
 7     /**
 8      * 1、这里至少将一种思想，该实现是不严谨的，因为没有两者之间没有监视器
 9      * 2、监视器只允许同一时间一个执行
10      * 3、该例子因为try中不是一个完整的方法，所以可能存在一个放入了对象还没打印，对方已经抢先又执行了一次
11      * @param args
12      */
13     public static void main(String[] args) {
14         /**
15          * LinkedBlockingQueue
16          * ArrayBlockingQueue
17          * PriortyBlockingQueue
18          * SynchronousQueue
19          */
20         SynchronousQueue queue = new SynchronousQueue();
21         Thread thread = new Thread() {
22             @Override
23             public void run() {
24                 while(true) {
25                     try {
26                         Thread.sleep(1000L);
27                         queue.put(new Object());
28                         System.out.println(Thread.currentThread().getName()+" 我执行完了!");
29                     } catch (InterruptedException e) {
30                         e.printStackTrace();
31                     }
32                 }
33             }
34             
35         };
36         thread.start();
37         while(true) {
38             try {
39                 Thread.sleep(1000L);
40                 queue.take();
41                 System.out.println(Thread.currentThread().getName()+" 我执行完了!");
42             } catch (InterruptedException e) {
43                 e.printStackTrace();
44             }
45         }
46     }
47 }