diff --git a/java/src/com/android/inputmethod/keyboard/internal/GesturePreviewTrail.java b/java/src/com/android/inputmethod/keyboard/internal/GesturePreviewTrail.java
index e3e6d39..f682b51 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/GesturePreviewTrail.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/GesturePreviewTrail.java
@@ -37,6 +37,7 @@
 final class GesturePreviewTrail {
     private static final int DEFAULT_CAPACITY = GestureStrokeWithPreviewPoints.PREVIEW_CAPACITY;
 
+    // These three {@link ResizableIntArray}s should be synchronized by {@link #mEventTimes}.
     private final ResizableIntArray mXCoordinates = new ResizableIntArray(DEFAULT_CAPACITY);
     private final ResizableIntArray mYCoordinates = new ResizableIntArray(DEFAULT_CAPACITY);
     private final ResizableIntArray mEventTimes = new ResizableIntArray(DEFAULT_CAPACITY);
@@ -90,7 +91,13 @@
     }
 
     public void addStroke(final GestureStrokeWithPreviewPoints stroke, final long downTime) {
-        final int trailSize = mEventTimes.getLength();
+        synchronized (mEventTimes) {
+            addStrokeLocked(stroke, downTime);
+        }
+    }
+
+    private void addStrokeLocked(final GestureStrokeWithPreviewPoints stroke, final long downTime) {
+            final int trailSize = mEventTimes.getLength();
         stroke.appendPreviewStroke(mEventTimes, mXCoordinates, mYCoordinates);
         if (mEventTimes.getLength() == trailSize) {
             return;
@@ -169,6 +176,13 @@
      */
     public boolean drawGestureTrail(final Canvas canvas, final Paint paint,
             final Rect outBoundsRect, final Params params) {
+        synchronized (mEventTimes) {
+            return drawGestureTrailLocked(canvas, paint, outBoundsRect, params);
+        }
+    }
+
+    private boolean drawGestureTrailLocked(final Canvas canvas, final Paint paint,
+            final Rect outBoundsRect, final Params params) {
         // Initialize bounds rectangle.
         outBoundsRect.setEmpty();
         final int trailSize = mEventTimes.getLength();
diff --git a/java/src/com/android/inputmethod/keyboard/internal/PointerTrackerQueue.java b/java/src/com/android/inputmethod/keyboard/internal/PointerTrackerQueue.java
index 2df7e5c..6bc6acc 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/PointerTrackerQueue.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/PointerTrackerQueue.java
@@ -34,175 +34,197 @@
     }
 
     private static final int INITIAL_CAPACITY = 10;
+    // Note: {@link #mExpandableArrayOfActivePointers} and {@link #mArraySize} are synchronized by
+    // {@link #mExpandableArrayOfActivePointers}
     private final ArrayList<Element> mExpandableArrayOfActivePointers =
             CollectionUtils.newArrayList(INITIAL_CAPACITY);
     private int mArraySize = 0;
 
-    public synchronized int size() {
-        return mArraySize;
-    }
-
-    public synchronized void add(final Element pointer) {
-        final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
-        final int arraySize = mArraySize;
-        if (arraySize < expandableArray.size()) {
-            expandableArray.set(arraySize, pointer);
-        } else {
-            expandableArray.add(pointer);
+    public int size() {
+        synchronized (mExpandableArrayOfActivePointers) {
+            return mArraySize;
         }
-        mArraySize = arraySize + 1;
     }
 
-    public synchronized void remove(final Element pointer) {
-        final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
-        final int arraySize = mArraySize;
-        int newSize = 0;
-        for (int index = 0; index < arraySize; index++) {
-            final Element element = expandableArray.get(index);
-            if (element == pointer) {
+    public void add(final Element pointer) {
+        synchronized (mExpandableArrayOfActivePointers) {
+            final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
+            final int arraySize = mArraySize;
+            if (arraySize < expandableArray.size()) {
+                expandableArray.set(arraySize, pointer);
+            } else {
+                expandableArray.add(pointer);
+            }
+            mArraySize = arraySize + 1;
+        }
+    }
+
+    public void remove(final Element pointer) {
+        synchronized (mExpandableArrayOfActivePointers) {
+            final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
+            final int arraySize = mArraySize;
+            int newSize = 0;
+            for (int index = 0; index < arraySize; index++) {
+                final Element element = expandableArray.get(index);
+                if (element == pointer) {
+                    if (newSize != index) {
+                        Log.w(TAG, "Found duplicated element in remove: " + pointer);
+                    }
+                    continue; // Remove this element from the expandableArray.
+                }
                 if (newSize != index) {
-                    Log.w(TAG, "Found duplicated element in remove: " + pointer);
+                    // Shift this element toward the beginning of the expandableArray.
+                    expandableArray.set(newSize, element);
                 }
-                continue; // Remove this element from the expandableArray.
-            }
-            if (newSize != index) {
-                // Shift this element toward the beginning of the expandableArray.
-                expandableArray.set(newSize, element);
-            }
-            newSize++;
-        }
-        mArraySize = newSize;
-    }
-
-    public synchronized Element getOldestElement() {
-        return (mArraySize == 0) ? null : mExpandableArrayOfActivePointers.get(0);
-    }
-
-    public synchronized void releaseAllPointersOlderThan(final Element pointer,
-            final long eventTime) {
-        if (DEBUG) {
-            Log.d(TAG, "releaseAllPoniterOlderThan: " + pointer + " " + this);
-        }
-        final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
-        final int arraySize = mArraySize;
-        int newSize, index;
-        for (newSize = index = 0; index < arraySize; index++) {
-            final Element element = expandableArray.get(index);
-            if (element == pointer) {
-                break; // Stop releasing elements.
-            }
-            if (!element.isModifier()) {
-                element.onPhantomUpEvent(eventTime);
-                continue; // Remove this element from the expandableArray.
-            }
-            if (newSize != index) {
-                // Shift this element toward the beginning of the expandableArray.
-                expandableArray.set(newSize, element);
-            }
-            newSize++;
-        }
-        // Shift rest of the expandableArray.
-        int count = 0;
-        for (; index < arraySize; index++) {
-            final Element element = expandableArray.get(index);
-            if (element == pointer) {
-                if (count > 0) {
-                    Log.w(TAG, "Found duplicated element in releaseAllPointersOlderThan: "
-                            + pointer);
-                }
-                count++;
-            }
-            if (newSize != index) {
-                expandableArray.set(newSize, expandableArray.get(index));
                 newSize++;
             }
+            mArraySize = newSize;
         }
-        mArraySize = newSize;
+    }
+
+    public Element getOldestElement() {
+        synchronized (mExpandableArrayOfActivePointers) {
+            return (mArraySize == 0) ? null : mExpandableArrayOfActivePointers.get(0);
+        }
+    }
+
+    public void releaseAllPointersOlderThan(final Element pointer, final long eventTime) {
+        synchronized (mExpandableArrayOfActivePointers) {
+            if (DEBUG) {
+                Log.d(TAG, "releaseAllPoniterOlderThan: " + pointer + " " + this);
+            }
+            final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
+            final int arraySize = mArraySize;
+            int newSize, index;
+            for (newSize = index = 0; index < arraySize; index++) {
+                final Element element = expandableArray.get(index);
+                if (element == pointer) {
+                    break; // Stop releasing elements.
+                }
+                if (!element.isModifier()) {
+                    element.onPhantomUpEvent(eventTime);
+                    continue; // Remove this element from the expandableArray.
+                }
+                if (newSize != index) {
+                    // Shift this element toward the beginning of the expandableArray.
+                    expandableArray.set(newSize, element);
+                }
+                newSize++;
+            }
+            // Shift rest of the expandableArray.
+            int count = 0;
+            for (; index < arraySize; index++) {
+                final Element element = expandableArray.get(index);
+                if (element == pointer) {
+                    if (count > 0) {
+                        Log.w(TAG, "Found duplicated element in releaseAllPointersOlderThan: "
+                                + pointer);
+                    }
+                    count++;
+                }
+                if (newSize != index) {
+                    expandableArray.set(newSize, expandableArray.get(index));
+                    newSize++;
+                }
+            }
+            mArraySize = newSize;
+        }
     }
 
     public void releaseAllPointers(final long eventTime) {
         releaseAllPointersExcept(null, eventTime);
     }
 
-    public synchronized void releaseAllPointersExcept(final Element pointer,
-            final long eventTime) {
-        if (DEBUG) {
-            if (pointer == null) {
-                Log.d(TAG, "releaseAllPoniters: " + this);
-            } else {
-                Log.d(TAG, "releaseAllPoniterExcept: " + pointer + " " + this);
-            }
-        }
-        final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
-        final int arraySize = mArraySize;
-        int newSize = 0, count = 0;
-        for (int index = 0; index < arraySize; index++) {
-            final Element element = expandableArray.get(index);
-            if (element == pointer) {
-                if (count > 0) {
-                    Log.w(TAG, "Found duplicated element in releaseAllPointersExcept: " + pointer);
+    public void releaseAllPointersExcept(final Element pointer, final long eventTime) {
+        synchronized (mExpandableArrayOfActivePointers) {
+            if (DEBUG) {
+                if (pointer == null) {
+                    Log.d(TAG, "releaseAllPoniters: " + this);
+                } else {
+                    Log.d(TAG, "releaseAllPoniterExcept: " + pointer + " " + this);
                 }
-                count++;
-            } else {
-                element.onPhantomUpEvent(eventTime);
-                continue; // Remove this element from the expandableArray.
             }
-            if (newSize != index) {
-                // Shift this element toward the beginning of the expandableArray.
-                expandableArray.set(newSize, element);
+            final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
+            final int arraySize = mArraySize;
+            int newSize = 0, count = 0;
+            for (int index = 0; index < arraySize; index++) {
+                final Element element = expandableArray.get(index);
+                if (element == pointer) {
+                    if (count > 0) {
+                        Log.w(TAG, "Found duplicated element in releaseAllPointersExcept: "
+                                + pointer);
+                    }
+                    count++;
+                } else {
+                    element.onPhantomUpEvent(eventTime);
+                    continue; // Remove this element from the expandableArray.
+                }
+                if (newSize != index) {
+                    // Shift this element toward the beginning of the expandableArray.
+                    expandableArray.set(newSize, element);
+                }
+                newSize++;
             }
-            newSize++;
+            mArraySize = newSize;
         }
-        mArraySize = newSize;
     }
 
-    public synchronized boolean hasModifierKeyOlderThan(final Element pointer) {
-        final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
-        final int arraySize = mArraySize;
-        for (int index = 0; index < arraySize; index++) {
-            final Element element = expandableArray.get(index);
-            if (element == pointer) {
-                return false; // Stop searching modifier key.
+    public boolean hasModifierKeyOlderThan(final Element pointer) {
+        synchronized (mExpandableArrayOfActivePointers) {
+            final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
+            final int arraySize = mArraySize;
+            for (int index = 0; index < arraySize; index++) {
+                final Element element = expandableArray.get(index);
+                if (element == pointer) {
+                    return false; // Stop searching modifier key.
+                }
+                if (element.isModifier()) {
+                    return true;
+                }
             }
-            if (element.isModifier()) {
-                return true;
-            }
+            return false;
         }
-        return false;
     }
 
-    public synchronized boolean isAnyInSlidingKeyInput() {
-        final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
-        final int arraySize = mArraySize;
-        for (int index = 0; index < arraySize; index++) {
-            final Element element = expandableArray.get(index);
-            if (element.isInSlidingKeyInput()) {
-                return true;
+    public boolean isAnyInSlidingKeyInput() {
+        synchronized (mExpandableArrayOfActivePointers) {
+            final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
+            final int arraySize = mArraySize;
+            for (int index = 0; index < arraySize; index++) {
+                final Element element = expandableArray.get(index);
+                if (element.isInSlidingKeyInput()) {
+                    return true;
+                }
             }
+            return false;
         }
-        return false;
     }
 
-    public synchronized void cancelAllPointerTracker() {
-        final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
-        final int arraySize = mArraySize;
-        for (int index = 0; index < arraySize; index++) {
-            final Element element = expandableArray.get(index);
-            element.cancelTracking();
+    public void cancelAllPointerTracker() {
+        synchronized (mExpandableArrayOfActivePointers) {
+            final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
+            final int arraySize = mArraySize;
+            for (int index = 0; index < arraySize; index++) {
+                final Element element = expandableArray.get(index);
+                element.cancelTracking();
+            }
         }
     }
 
     @Override
-    public synchronized String toString() {
-        final StringBuilder sb = new StringBuilder();
-        final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
-        final int arraySize = mArraySize;
-        for (int index = 0; index < arraySize; index++) {
-            final Element element = expandableArray.get(index);
-            if (sb.length() > 0)
-                sb.append(" ");
-            sb.append(element.toString());
+    public String toString() {
+        synchronized (mExpandableArrayOfActivePointers) {
+            final StringBuilder sb = new StringBuilder();
+            final ArrayList<Element> expandableArray = mExpandableArrayOfActivePointers;
+            final int arraySize = mArraySize;
+            for (int index = 0; index < arraySize; index++) {
+                final Element element = expandableArray.get(index);
+                if (sb.length() > 0) {
+                    sb.append(" ");
+                }
+                sb.append(element.toString());
+            }
+            return "[" + sb.toString() + "]";
         }
-        return "[" + sb.toString() + "]";
     }
 }
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index db51131..0f1f149 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -1552,7 +1552,8 @@
     private static final class BatchInputUpdater implements Handler.Callback {
         private final Handler mHandler;
         private LatinIME mLatinIme;
-        private boolean mInBatchInput; // synchronized using "this".
+        private final Object mLock = new Object();
+        private boolean mInBatchInput; // synchronized using {@link #mLock}.
 
         private BatchInputUpdater() {
             final HandlerThread handlerThread = new HandlerThread(
@@ -1583,21 +1584,25 @@
         }
 
         // Run in the UI thread.
-        public synchronized void onStartBatchInput(final LatinIME latinIme) {
-            mHandler.removeMessages(MSG_UPDATE_GESTURE_PREVIEW_AND_SUGGESTION_STRIP);
-            mLatinIme = latinIme;
-            mInBatchInput = true;
+        public void onStartBatchInput(final LatinIME latinIme) {
+            synchronized (mLock) {
+                mHandler.removeMessages(MSG_UPDATE_GESTURE_PREVIEW_AND_SUGGESTION_STRIP);
+                mLatinIme = latinIme;
+                mInBatchInput = true;
+            }
         }
 
         // Run in the Handler thread.
-        private synchronized void updateBatchInput(final InputPointers batchPointers) {
-            if (!mInBatchInput) {
-                // Batch input has ended or canceled while the message was being delivered.
-                return;
+        private void updateBatchInput(final InputPointers batchPointers) {
+            synchronized (mLock) {
+                if (!mInBatchInput) {
+                    // Batch input has ended or canceled while the message was being delivered.
+                    return;
+                }
+                final SuggestedWords suggestedWords = getSuggestedWordsGestureLocked(batchPointers);
+                mLatinIme.mHandler.showGesturePreviewAndSuggestionStrip(
+                        suggestedWords, false /* dismissGestureFloatingPreviewText */);
             }
-            final SuggestedWords suggestedWords = getSuggestedWordsGestureLocked(batchPointers);
-            mLatinIme.mHandler.showGesturePreviewAndSuggestionStrip(
-                    suggestedWords, false /* dismissGestureFloatingPreviewText */);
         }
 
         // Run in the UI thread.
@@ -1610,19 +1615,23 @@
                     .sendToTarget();
         }
 
-        public synchronized void onCancelBatchInput() {
-            mInBatchInput = false;
-            mLatinIme.mHandler.showGesturePreviewAndSuggestionStrip(
-                    SuggestedWords.EMPTY, true /* dismissGestureFloatingPreviewText */);
+        public void onCancelBatchInput() {
+            synchronized (mLock) {
+                mInBatchInput = false;
+                mLatinIme.mHandler.showGesturePreviewAndSuggestionStrip(
+                        SuggestedWords.EMPTY, true /* dismissGestureFloatingPreviewText */);
+            }
         }
 
         // Run in the UI thread.
-        public synchronized SuggestedWords onEndBatchInput(final InputPointers batchPointers) {
-            mInBatchInput = false;
-            final SuggestedWords suggestedWords = getSuggestedWordsGestureLocked(batchPointers);
-            mLatinIme.mHandler.showGesturePreviewAndSuggestionStrip(
-                    suggestedWords, true /* dismissGestureFloatingPreviewText */);
-            return suggestedWords;
+        public SuggestedWords onEndBatchInput(final InputPointers batchPointers) {
+            synchronized (mLock) {
+                mInBatchInput = false;
+                final SuggestedWords suggestedWords = getSuggestedWordsGestureLocked(batchPointers);
+                mLatinIme.mHandler.showGesturePreviewAndSuggestionStrip(
+                        suggestedWords, true /* dismissGestureFloatingPreviewText */);
+                return suggestedWords;
+            }
         }
 
         // {@link LatinIME#getSuggestedWords(int)} method calls with same session id have to