君子博学而日参省乎己 则知明而行无过矣

博客园 首页 新随笔 联系 订阅 管理
面试题——在多线程环境下如何保证一个List集合中的元素不超过15个

这是有一次去面试被问到的，当时只知道用synchronized来保证同步，但面试官说除了此方式的其它实现，现在写下它的各种实现：

1、JDK1.5之前的内置锁synchronized实现

 模仿JDK1.5之前同步集合SynchronizedList的实现，内部使用synchronized对一个对一个List的封装，如下代码：

Java代码  收藏代码
  1. /** 
  2.  * @description 
  3.  *  
  4.  * @author chenzehe 
  5.  * @email hljuczh@163.com 
  6.  * @create 2013-2-22 下午05:03:43 
  7.  */  
  8. public class SyncList<E> implements List<E> {  
  9.     final Object    mutex;  
  10.     final List<E> list;  
  11.     final int       fixSize;      
  12.     public SyncList(List list, int fixSize) {  
  13.         super();  
  14.         mutex = this;  
  15.         this.list = list;  
  16.         this.fixSize = fixSize;  
  17.     }     
  18.     @Override  
  19.     public boolean add(E e) {  
  20.         synchronized (mutex) {  
  21.             if (list.size() < fixSize) {  
  22.                 System.out.println("add成功，size=" + list.size());  
  23.                 return list.add(e);  
  24.             }  
  25.             else {  
  26.                 System.out.println("大小已超过fixSize，不能再add...");  
  27.                 return false;  
  28.             }  
  29.         }  
  30.           
  31.     }     
  32.     @Override  
  33.     public E remove(int index) {  
  34.         synchronized (mutex) {  
  35.             if (list.size() > 0) {  
  36.                 System.out.println("删除成功...");  
  37.                 return list.remove(index);  
  38.             }  
  39.             else {  
  40.                 return null;  
  41.             }  
  42.         }  
  43.     }  
  44.         ......  
  45. }  

 测试类，模拟几个线程对该集合进行操作：

Java代码  收藏代码
  1. /** 
  2.  * @description 
  3.  *  
  4.  * @author chenzehe 
  5.  * @email hljuczh@163.com 
  6.  * @create 2013-2-22 下午05:49:40 
  7.  */  
  8. public class SyncListTest {   
  9.     public static void main(String[] args) {  
  10.         int fixSize = 10;  
  11.         SyncList<Integer> syncList = new SyncList<Integer>(new ArrayList<Integer>(), fixSize);  
  12.         AddThread addThread = new AddThread(syncList);  
  13.         RemoveThread removeThread = new RemoveThread(syncList);  
  14.         new Thread(addThread).start();  
  15.         new Thread(addThread).start();  
  16.         new Thread(removeThread).start();  
  17.     }     
  18. }  
  19.   
  20. class AddThread implements Runnable {  
  21.     private SyncList<Integer> syncList;  
  22.       
  23.     public AddThread(SyncList<Integer> syncList) {  
  24.         this.syncList = syncList;  
  25.     }     
  26.     @Override  
  27.     public void run() {  
  28.         for (int i = 0; i < 20; i++) {  
  29.             syncList.add(i);  
  30.             try {  
  31.                 Thread.sleep(100);  
  32.             }  
  33.             catch (InterruptedException e) {  
  34.                 e.printStackTrace();  
  35.             }  
  36.         }  
  37.     }  
  38. }  
  39.   
  40. class RemoveThread implements Runnable {  
  41.     private SyncList<Integer> syncList;  
  42.       
  43.     public RemoveThread(SyncList<Integer> syncList) {  
  44.         this.syncList = syncList;  
  45.     }  
  46.       
  47.     @Override  
  48.     public void run() {  
  49.         for (int i = 0; i < 10; i++) {  
  50.             syncList.remove(0);  
  51.             try {  
  52.                 Thread.sleep(300);  
  53.             }  
  54.             catch (InterruptedException e) {  
  55.                 e.printStackTrace();  
  56.             }  
  57.         }  
  58.     }  
  59.       
  60. }  

 输出：

Java代码  收藏代码
  1. add成功，size=0  
  2. add成功，size=1  
  3. 删除成功...  
  4. add成功，size=1  
  5. add成功，size=2  
  6. add成功，size=3  
  7. add成功，size=4  
  8. 删除成功...  
  9. add成功，size=4  
  10. add成功，size=5  
  11. add成功，size=6  
  12. add成功，size=7  
  13. add成功，size=8  
  14. add成功，size=9  
  15. 大小已超过fixSize，不能再add...  
  16. 大小已超过fixSize，不能再add...  
  17. 删除成功...  
  18. add成功，size=9  
  19. 大小已超过fixSize，不能再add...  
  20. ...   

 2、JDK1.5之前的显示锁，并使用Condition控制当集合中的元素达到最大时使线程等待，如下代码：

 

Java代码  收藏代码
  1. /** 
  2.  * @description 
  3.  *  
  4.  * @author chenzehe 
  5.  * @email hljuczh@163.com 
  6.  * @create 2013-2-22 下午06:43:06 
  7.  */  
  8.   
  9. public class ReentrantLockList<E> implements List<E> {  
  10.     final List<E>             list;  
  11.     final int                   fixSize;  
  12.       
  13.     private final ReadWriteLock lock        = new ReentrantReadWriteLock();  
  14.     private final Lock          r           = lock.readLock();  
  15.     private final Lock          w           = lock.writeLock();  
  16.     final Condition             notFull     = w.newCondition();  
  17.     final Condition             notEmpty    = w.newCondition();  
  18.       
  19.     public ReentrantLockList(List<E> list, int fixSize) {  
  20.         super();  
  21.         this.list = list;  
  22.         this.fixSize = fixSize;  
  23.     }  
  24.       
  25.     @Override  
  26.     public boolean add(E e) {  
  27.         boolean addResult = false;  
  28.         w.lock();  
  29.         try {  
  30.             while (list.size() >= fixSize) {  
  31.                 System.out.println("大小已超过fixSize不能再添加，在等待中...");  
  32.                 notFull.await();// Causes the current thread to wait until it is signalled or interrupted  
  33.             }  
  34.             addResult = list.add(e);  
  35.             System.out.println("add成功，size=" + list.size());  
  36.             notEmpty.signal();// Wakes up one waiting thread  
  37.         }  
  38.         catch (InterruptedException e2) {  
  39.             e2.printStackTrace();  
  40.         }  
  41.         finally {  
  42.             w.unlock();  
  43.         }  
  44.         return addResult;  
  45.     }  
  46.       
  47.     @Override  
  48.     public E remove(int index) {  
  49.         E removeResult = null;  
  50.         w.lock();  
  51.         try {  
  52.             while (list.size() < 1) {  
  53.                 System.out.println("集合为空不能删除，在等待中...");  
  54.                 notEmpty.await();// Causes the current thread to wait until it is signalled or interrupted  
  55.             }  
  56.             removeResult = list.remove(index);  
  57.             System.out.println("删除成功...");  
  58.             notFull.signal();// Wakes up one waiting thread  
  59.         }  
  60.         catch (InterruptedException e2) {  
  61.             e2.printStackTrace();  
  62.         }  
  63.         finally {  
  64.             w.unlock();  
  65.         }  
  66.         return removeResult;  
  67.           
  68.     }  
  69.     ......  
  70. }  

 测试类模拟几个线程同时对该集体进行操作：

 

 

Java代码  收藏代码
  1. /** 
  2.  * @description 
  3.  *  
  4.  * @author chenzehe 
  5.  * @email hljuczh@163.com 
  6.  * @create 2013-2-22 下午07:04:50 
  7.  */  
  8.   
  9. public class ReentrantLockListTest {  
  10.       
  11.     public static void main(String[] args) {  
  12.         int fixSize = 10;  
  13.         ReentrantLockList<Integer> reentrantLockList = new ReentrantLockList<Integer>(new ArrayList<Integer>(), fixSize);  
  14.         AddReentrantLockListThread addThread = new AddReentrantLockListThread(reentrantLockList);  
  15.         RemoveReentrantLockListThread removeThread = new RemoveReentrantLockListThread(reentrantLockList);  
  16.         new Thread(addThread).start();  
  17.         new Thread(addThread).start();  
  18.         new Thread(removeThread).start();         
  19.     }  
  20.       
  21. }  
  22.   
  23. class AddReentrantLockListThread implements Runnable {  
  24.     private ReentrantLockList<Integer>    reentrantLockList;  
  25.       
  26.     public AddReentrantLockListThread(ReentrantLockList<Integer> reentrantLockList) {  
  27.         this.reentrantLockList = reentrantLockList;  
  28.     }  
  29.       
  30.     @Override  
  31.     public void run() {  
  32.         for (int i = 0; i < 20; i++) {  
  33.             reentrantLockList.add(i);  
  34.             try {  
  35.                 Thread.sleep(100);  
  36.             }  
  37.             catch (InterruptedException e) {  
  38.                 e.printStackTrace();  
  39.             }  
  40.         }  
  41.     }  
  42. }  
  43.   
  44. class RemoveReentrantLockListThread implements Runnable {  
  45.     private ReentrantLockList<Integer>    reentrantLockList;  
  46.       
  47.     public RemoveReentrantLockListThread(ReentrantLockList<Integer> reentrantLockList) {  
  48.         this.reentrantLockList = reentrantLockList;  
  49.     }  
  50.       
  51.     @Override  
  52.     public void run() {  
  53.         for (int i = 0; i < 10; i++) {  
  54.             reentrantLockList.remove(0);  
  55.             try {  
  56.                 Thread.sleep(300);  
  57.             }  
  58.             catch (InterruptedException e) {  
  59.                 e.printStackTrace();  
  60.             }  
  61.         }  
  62.     }  
  63.       
  64. }  

 

 

 输出结果：

 

Java代码  收藏代码
  1. 集合为空不能删除，在等待中...  
  2. add成功，size=1  
  3. add成功，size=2  
  4. 删除成功...  
  5. add成功，size=2  
  6. add成功，size=3  
  7. add成功，size=4  
  8. add成功，size=5  
  9. add成功，size=6  
  10. 删除成功...  
  11. add成功，size=6  
  12. add成功，size=7  
  13. add成功，size=8  
  14. add成功，size=9  
  15. add成功，size=10  
  16. 大小已超过fixSize不能再添加，在等待中...  
  17. 删除成功...  
  18. add成功，size=10  
  19. 大小已超过fixSize不能再添加，在等待中...  
  20. 大小已超过fixSize不能再添加，在等待中...  
  21. 删除成功...  
  22. add成功，size=10  
  23. 大小已超过fixSize不能再添加，在等待中...  
  24. ...  
posted on 2013-07-23 01:39  刺猬的温驯  阅读(369)  评论(0)  编辑  收藏  举报