felix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rickh...@apache.org
Subject svn commit: r726867 - /felix/trunk/framework/src/main/java/org/apache/felix/framework/Felix.java
Date Mon, 15 Dec 2008 22:50:59 GMT
Author: rickhall
Date: Mon Dec 15 14:50:59 2008
New Revision: 726867

URL: http://svn.apache.org/viewvc?rev=726867&view=rev
Log:
Fixed/improved the global locking code for refreshes and resolves; now
bundle locks can be promoted to global locks.

Modified:
    felix/trunk/framework/src/main/java/org/apache/felix/framework/Felix.java

Modified: felix/trunk/framework/src/main/java/org/apache/felix/framework/Felix.java
URL: http://svn.apache.org/viewvc/felix/trunk/framework/src/main/java/org/apache/felix/framework/Felix.java?rev=726867&r1=726866&r2=726867&view=diff
==============================================================================
--- felix/trunk/framework/src/main/java/org/apache/felix/framework/Felix.java (original)
+++ felix/trunk/framework/src/main/java/org/apache/felix/framework/Felix.java Mon Dec 15 14:50:59
2008
@@ -38,7 +38,7 @@
 public class Felix extends FelixBundle implements Framework
 {
     // The secure action used to do privileged calls
-    static SecureAction m_secureAction = new SecureAction();
+    static final SecureAction m_secureAction = new SecureAction();
 
     // The extension manager to handle extension bundles
     ExtensionManager m_extensionManager;
@@ -54,17 +54,24 @@
     private IModuleFactory m_factory = null;
     private R4SearchPolicyCore m_policyCore = null;
 
-    // Object used as a lock when calculating which bundles
-    // when performing an operation on one or more bundles.
-    private Object[] m_bundleLock = new Object[0];
+    // Lock object used to determine if an individual bundle
+    // lock or the global lock can be acquired.
+    private final Object[] m_bundleLock = new Object[0];
+    // Maps a thread object to a single-element int array to
+    // keep track of how many locks the thread has acquired.
+    private final Map m_lockingThreadMap = new HashMap();
+    // Separately keeps track of how many times the global
+    // lock was acquired by a given thread; if this value is
+    // zero, then it means the global lock is free.
+    private int m_globalLockCount = 0;
 
     // Maps a bundle location to a bundle location;
     // used to reserve a location when installing a bundle.
-    private Map m_installRequestMap = new HashMap();
+    private final Map m_installRequestMap = new HashMap();
     // This lock must be acquired to modify m_installRequestMap;
     // to help avoid deadlock this lock as priority 1 and should
     // be acquired before locks with lower priority.
-    private Object[] m_installRequestLock_Priority1 = new Object[0];
+    private final Object[] m_installRequestLock_Priority1 = new Object[0];
 
     // Maps a bundle location to a bundle.
     private HashMap m_installedBundleMap;
@@ -72,14 +79,14 @@
     // This lock must be acquired to modify m_installedBundleMap;
     // to help avoid deadlock this lock as priority 2 and should
     // be acquired before locks with lower priority.
-    private Object[] m_installedBundleLock_Priority2 = new Object[0];
+    private final Object[] m_installedBundleLock_Priority2 = new Object[0];
 
     // An array of uninstalled bundles before a refresh occurs.
     private FelixBundle[] m_uninstalledBundles = null;
     // This lock must be acquired to modify m_uninstalledBundles;
     // to help avoid deadlock this lock as priority 3 and should
     // be acquired before locks with lower priority.
-    private Object[] m_uninstalledBundlesLock_Priority3 = new Object[0];
+    private final Object[] m_uninstalledBundlesLock_Priority3 = new Object[0];
 
     // Framework's active start level.
     private int m_activeStartLevel =
@@ -96,7 +103,7 @@
 
     // Next available bundle identifier.
     private long m_nextId = 1L;
-    private Object m_nextIdLock = new Object[0];
+    private final Object m_nextIdLock = new Object[0];
 
     // List of event listeners.
     private EventDispatcher m_dispatcher = null;
@@ -4177,14 +4184,14 @@
         }
     }
 
-    private long m_lockCount = 0;
-    private Thread m_lockThread = null;
-
-    protected void acquireBundleLock(FelixBundle bundle)
+    void acquireBundleLock(FelixBundle bundle)
     {
         synchronized (m_bundleLock)
         {
-            while ((m_lockCount < 0) && (m_lockThread != Thread.currentThread()))
+            // Wait if any thread has the global lock, unless the current thread
+            // holds the global lock.
+            while ((m_globalLockCount > 0)
+                && m_lockingThreadMap.containsKey(Thread.currentThread()))
             {
                 try
                 {
@@ -4195,8 +4202,17 @@
                     // Ignore and just keep waiting.
                 }
             }
-            m_lockCount++;
 
+            // Increment the current thread's lock count.
+            int[] counter = (int[]) m_lockingThreadMap.get(Thread.currentThread());
+            if (counter == null)
+            {
+                counter = new int[] { 0 };
+            }
+            counter[0]++;
+            m_lockingThreadMap.put(Thread.currentThread(), counter);
+
+            // Wait until the bundle lock is available, then lock it.
             while (!bundle.getInfo().isLockable())
             {
                 try
@@ -4212,11 +4228,14 @@
         }
     }
 
-    protected boolean acquireBundleLockOrFail(FelixBundle bundle)
+    private boolean acquireBundleLockOrFail(FelixBundle bundle)
     {
         synchronized (m_bundleLock)
         {
-            while ((m_lockCount < 0) && (m_lockThread != Thread.currentThread()))
+            // Wait if any thread has the global lock, unless the current thread
+            // holds the global lock.
+            while ((m_globalLockCount > 0)
+                && m_lockingThreadMap.containsKey(Thread.currentThread()))
             {
                 try
                 {
@@ -4227,27 +4246,58 @@
                     // Ignore and just keep waiting.
                 }
             }
-            m_lockCount++;
+
+            // Return immediately if the bundle lock is not available.
             if (!bundle.getInfo().isLockable())
             {
                 return false;
             }
+
+            // Increment the current thread's lock count.
+            int[] counter = (int[]) m_lockingThreadMap.get(Thread.currentThread());
+            if (counter == null)
+            {
+                counter = new int[] { 0 };
+            }
+            counter[0]++;
+            m_lockingThreadMap.put(Thread.currentThread(), counter);
+
+            // Acquire the bundle lock.
             bundle.getInfo().lock();
             return true;
         }
     }
 
-    protected void releaseBundleLock(FelixBundle bundle)
+    void releaseBundleLock(FelixBundle bundle)
     {
         synchronized (m_bundleLock)
         {
-            m_lockCount--;
+            // Decrement the current thread's lock count.
+            int[] counter = (int[]) m_lockingThreadMap.get(Thread.currentThread());
+            if (counter != null)
+            {
+                counter[0]--;
+                if (counter[0] == 0)
+                {
+                    m_lockingThreadMap.remove(Thread.currentThread());
+                }
+                else
+                {
+                    m_lockingThreadMap.put(Thread.currentThread(), counter);
+                }
+            }
+            else
+            {
+                m_logger.log(Logger.LOG_ERROR, "Thread released a lock it doesn't own: "
+ bundle);
+            }
+
+            // Unlock the bundle.
             bundle.getInfo().unlock();
             m_bundleLock.notifyAll();
         }
     }
 
-    protected FelixBundle[] acquireBundleResolveLocks(Bundle[] targets)
+    private FelixBundle[] acquireBundleResolveLocks(Bundle[] targets)
     {
         // Hold bundles to be locked.
         FelixBundle[] bundles = null;
@@ -4263,7 +4313,12 @@
 
         synchronized (m_bundleLock)
         {
-            while (m_lockCount != 0)
+            // Wait as long as there are multiple threads holding locks,
+            // but proceed if there are no lock holders or the current thread
+            // is the only lock holder.
+            while ((m_lockingThreadMap.size() > 1)
+               || ((m_lockingThreadMap.size() == 1)
+                   && !m_lockingThreadMap.containsKey(Thread.currentThread())))
             {
                 try
                 {
@@ -4274,89 +4329,69 @@
                     // Ignore
                 }
             }
-            m_lockCount = -1;
-            m_lockThread = Thread.currentThread();
 
-            boolean success = false;
-            while (!success)
+            // Increment the current thread's lock count.
+            int[] counter = (int[]) m_lockingThreadMap.get(Thread.currentThread());
+            if (counter == null)
             {
-                // If targets is null, then resolve all unresolved bundles.
-                if (targets == null)
-                {
-                    List list = new ArrayList();
+                counter = new int[] { 0 };
+            }
+            counter[0]++;
+            m_lockingThreadMap.put(Thread.currentThread(), counter);
 
-                    // Add all unresolved bundles to the list.
-                    synchronized (m_installedBundleLock_Priority2)
-                    {
-                        Iterator iter = m_installedBundleMap.values().iterator();
-                        while (iter.hasNext())
-                        {
-                            FelixBundle bundle = (FelixBundle) iter.next();
-                            if (bundle.getInfo().getState() == Bundle.INSTALLED)
-                            {
-                                list.add(bundle);
-                            }
-                        }
-                    }
+            // Increment the current thread's global lock count.
+            m_globalLockCount++;
 
-                    // Create an array.
-                    if (list.size() > 0)
-                    {
-                        bundles = (FelixBundle[]) list.toArray(new FelixBundle[list.size()]);
-                    }
-                }
+            // If targets is null, then resolve all unresolved bundles.
+            if (targets == null)
+            {
+                List list = new ArrayList();
 
-                // Check if all unresolved bundles can be locked.
-                boolean lockable = true;
-                if (bundles != null)
+                // Add all unresolved bundles to the list.
+                synchronized (m_installedBundleLock_Priority2)
                 {
-                    for (int i = 0; lockable && (i < bundles.length); i++)
-                    {
-                        lockable = bundles[i].getInfo().isLockable();
-                    }
-
-                    // If we can lock all bundles, then lock them.
-                    if (lockable)
-                    {
-                        for (int i = 0; i < bundles.length; i++)
-                        {
-                            bundles[i].getInfo().lock();
-                        }
-                        success = true;
-                    }
-                    // Otherwise, wait and try again.
-                    else
+                    Iterator iter = m_installedBundleMap.values().iterator();
+                    while (iter.hasNext())
                     {
-                        try
-                        {
-                            m_bundleLock.wait();
-                        }
-                        catch (InterruptedException ex)
+                        FelixBundle bundle = (FelixBundle) iter.next();
+                        if (bundle.getInfo().getState() == Bundle.INSTALLED)
                         {
-                            // Ignore and just keep waiting.
+                            list.add(bundle);
                         }
                     }
                 }
-                else
+
+                // Create an array.
+                if (list.size() > 0)
                 {
-                    // If there were no bundles to lock, then we can just
-                    // exit the lock loop.
-                    success = true;
+                    bundles = (FelixBundle[]) list.toArray(new FelixBundle[list.size()]);
                 }
             }
+
+            // Lock all needed bundles; this is not strictly
+            // necessary since we hold the global lock.
+            for (int i = 0; i < bundles.length; i++)
+            {
+                bundles[i].getInfo().lock();
+            }
         }
 
         return bundles;
     }
 
-    protected FelixBundle[] acquireBundleRefreshLocks(Bundle[] targets)
+    private FelixBundle[] acquireBundleRefreshLocks(Bundle[] targets)
     {
         // Hold bundles to be locked.
         FelixBundle[] bundles = null;
 
         synchronized (m_bundleLock)
         {
-            while (m_lockCount != 0)
+            // Wait as long as there are multiple threads holding locks,
+            // but proceed if there are no lock holders or the current thread
+            // is the only lock holder.
+            while ((m_lockingThreadMap.size() > 1)
+               || ((m_lockingThreadMap.size() == 1)
+                   && !m_lockingThreadMap.containsKey(Thread.currentThread())))
             {
                 try
                 {
@@ -4367,122 +4402,119 @@
                     // Ignore
                 }
             }
-            m_lockCount = -1;
-            m_lockThread = Thread.currentThread();
 
-            boolean success = false;
-            while (!success)
+            // Increment the current thread's lock count.
+            int[] counter = (int[]) m_lockingThreadMap.get(Thread.currentThread());
+            if (counter == null)
             {
-                // If targets is null, then refresh all pending bundles.
-                Bundle[] newTargets = targets;
-                if (newTargets == null)
-                {
-                    List list = new ArrayList();
-
-                    // First add all uninstalled bundles.
-                    synchronized (m_uninstalledBundlesLock_Priority3)
-                    {
-                        for (int i = 0;
-                            (m_uninstalledBundles != null) && (i < m_uninstalledBundles.length);
-                            i++)
-                        {
-                            list.add(m_uninstalledBundles[i]);
-                        }
-                    }
+                counter = new int[] { 0 };
+            }
+            counter[0]++;
+            m_lockingThreadMap.put(Thread.currentThread(), counter);
 
-                    // Then add all updated bundles.
-                    synchronized (m_installedBundleLock_Priority2)
-                    {
-                        Iterator iter = m_installedBundleMap.values().iterator();
-                        while (iter.hasNext())
-                        {
-                            FelixBundle bundle = (FelixBundle) iter.next();
-                            BundleInfo info = bundle.getInfo();
-                            if ((info instanceof RegularBundleInfo) &&
-                                (((RegularBundleInfo) info).getArchive().getRevisionCount()
> 1))
-                            {
-                                list.add(bundle);
-                            }
-                        }
-                    }
+            // Increment the current thread's global lock count.
+            m_globalLockCount++;
 
-                    // Create an array.
-                    if (list.size() > 0)
-                    {
-                        newTargets = (Bundle[]) list.toArray(new Bundle[list.size()]);
-                    }
-                }
+            // If targets is null, then refresh all pending bundles.
+            Bundle[] newTargets = targets;
+            if (newTargets == null)
+            {
+                List list = new ArrayList();
 
-                // If there are targets, then find all dependencies
-                // for each one.
-                if (newTargets != null)
+                // First add all uninstalled bundles.
+                synchronized (m_uninstalledBundlesLock_Priority3)
                 {
-                    // Create map of bundles that import the packages
-                    // from the target bundles.
-                    Map map = new HashMap();
-                    for (int targetIdx = 0; targetIdx < newTargets.length; targetIdx++)
+                    for (int i = 0;
+                        (m_uninstalledBundles != null) && (i < m_uninstalledBundles.length);
+                        i++)
                     {
-                        // Add the current target bundle to the map of
-                        // bundles to be refreshed.
-                        FelixBundle target = (FelixBundle) newTargets[targetIdx];
-                        map.put(target, target);
-                        // Add all importing bundles to map.
-                        populateDependentGraph(target, map);
+                        list.add(m_uninstalledBundles[i]);
                     }
-
-                    bundles = (FelixBundle[]) map.values().toArray(new FelixBundle[map.size()]);
                 }
 
-                // Check if all corresponding bundles can be locked.
-                boolean lockable = true;
-                if (bundles != null)
+                // Then add all updated bundles.
+                synchronized (m_installedBundleLock_Priority2)
                 {
-                    for (int i = 0; lockable && (i < bundles.length); i++)
+                    Iterator iter = m_installedBundleMap.values().iterator();
+                    while (iter.hasNext())
                     {
-                        lockable = bundles[i].getInfo().isLockable();
-                    }
-
-                    // If we can lock all bundles, then lock them.
-                    if (lockable)
-                    {
-                        for (int i = 0; i < bundles.length; i++)
+                        FelixBundle bundle = (FelixBundle) iter.next();
+                        BundleInfo info = bundle.getInfo();
+                        if ((info instanceof RegularBundleInfo) &&
+                            (((RegularBundleInfo) info).getArchive().getRevisionCount() >
1))
                         {
-                            bundles[i].getInfo().lock();
-                        }
-                        success = true;
-                    }
-                    // Otherwise, wait and try again.
-                    else
-                    {
-                        try
-                        {
-                            m_bundleLock.wait();
-                        }
-                        catch (InterruptedException ex)
-                        {
-                            // Ignore and just keep waiting.
+                            list.add(bundle);
                         }
                     }
                 }
-                else
+
+                // Create an array.
+                if (list.size() > 0)
                 {
-                    // If there were no bundles to lock, then we can just
-                    // exit the lock loop.
-                    success = true;
+                    newTargets = (Bundle[]) list.toArray(new Bundle[list.size()]);
                 }
             }
+
+            // If there are targets, then find all dependencies
+            // for each one.
+            if (newTargets != null)
+            {
+                // Create map of bundles that import the packages
+                // from the target bundles.
+                Map map = new HashMap();
+                for (int targetIdx = 0; targetIdx < newTargets.length; targetIdx++)
+                {
+                    // Add the current target bundle to the map of
+                    // bundles to be refreshed.
+                    FelixBundle target = (FelixBundle) newTargets[targetIdx];
+                    map.put(target, target);
+                    // Add all importing bundles to map.
+                    populateDependentGraph(target, map);
+                }
+
+                bundles = (FelixBundle[]) map.values().toArray(new FelixBundle[map.size()]);
+            }
+
+            // Lock all needed bundles; this is not strictly
+            // necessary since we hold the global lock.
+            for (int i = 0; i < bundles.length; i++)
+            {
+                bundles[i].getInfo().lock();
+            }
         }
 
         return bundles;
     }
 
-    protected void releaseBundleLocks(FelixBundle[] bundles)
+    private void releaseBundleLocks(FelixBundle[] bundles)
     {
         // Always unlock any locked bundles.
         synchronized (m_bundleLock)
         {
-            m_lockCount = 0;
-            m_lockThread = null;
+            // Decrement the current thread's lock count.
+            int[] counter = (int[]) m_lockingThreadMap.get(Thread.currentThread());
+            if (counter != null)
+            {
+                counter[0]--;
+                if (counter[0] == 0)
+                {
+                    m_lockingThreadMap.remove(Thread.currentThread());
+                }
+                else
+                {
+                    m_lockingThreadMap.put(Thread.currentThread(), counter);
+                }
+                counter = new int[] { 0 };
+            }
+            else
+            {
+                m_logger.log(Logger.LOG_ERROR, "Thread release a lock it doesn't own.");
+            }
+
+            // Decrement the current thread's global lock count;
+            m_globalLockCount--;
+
+            // Unlock all the bundles.
             for (int i = 0; (bundles != null) && (i < bundles.length); i++)
             {
                 bundles[i].getInfo().unlock();



Mime
View raw message