将mysql中的记录通过ThreadLocal传递给removeListCache方法.

@param model
320203
public static <BEAN, KEYTYPE> void transferModel(IGet<BEAN, KEYTYPE> mysqlImpl, KEYTYPE key) {
		BEAN bean = mysqlImpl.get(key);
		CURRENT_MODEL.set(bean);
	}
332229
public void removeTableModelListener(TableModelListener l)
    {
        try   {
            this.updateIfNewRow(-1);    // Update any locked record.
        } catch (DBException ex)    {
            ex.printStackTrace();
        }
        super.removeTableModelListener(l);
    }
1187329
public void remove() {
        Thread thread = Thread.currentThread();
        if (thread instanceof ThreadPool.Worker) {
            Object[] wsLocals = getThreadLocals((ThreadPool.Worker) thread);
            wsLocals[index] = null;
        } else {
            super.remove();
        }
    }
134709
@SuppressWarnings("unchecked")
    public boolean removeList(@NonNull ObservableList<? extends T> listToRemove) {
        int size = 0;
        for (int i = 0, listsSize = lists.size(); i < listsSize; i++) {
            List<? extends T> list = lists.get(i);
            if (list == listToRemove) {
                listToRemove.removeOnListChangedCallback(callback);
                lists.remove(i);
                modCount += 1;
                listeners.notifyRemoved(this, size, list.size());
                return true;
            }
            size += list.size();
        }
        return false;
    }
130056
private void setJoin(T model) {
        for (JoinParam joinParam : joinParams) {
            try {
                Object leftValue = AnimaUtils.invokeMethod(
                        model,
                        getGetterName(joinParam.getOnLeft()),
                        AnimaUtils.EMPTY_ARG);

                String sql = "SELECT * FROM " + AnimaCache.getTableName(joinParam.getJoinModel()) +
                        " WHERE " + joinParam.getOnRight() + " = ?";

                Field field = model.getClass()
                        .getDeclaredField(joinParam.getFieldName());


                if (field.getType().equals(List.class)) {
                    if (AnimaUtils.isNotEmpty(joinParam.getOrderBy())) {
                        sql += " ORDER BY " + joinParam.getOrderBy();
                    }
                    List<? extends Model> list = this.queryList(joinParam.getJoinModel(), sql, new Object[]{leftValue});
                    AnimaUtils.invokeMethod(model, getSetterName(joinParam.getFieldName()), new Object[]{list});
                }

                if (field.getType().equals(joinParam.getJoinModel())) {
                    Object joinObject = this.queryOne(joinParam.getJoinModel(), sql, new Object[]{leftValue});
                    AnimaUtils.invokeMethod(model, getSetterName(joinParam.getFieldName()), new Object[]{joinObject});
                }
            } catch (NoSuchFieldException e) {
                log.error("Set join error", e);
            }
        }
    }
911328
@UiThread
  public void delete(List<T> annotationList) {
    for (T annotation : annotationList) {
      annotations.remove(annotation.getId());
    }
    updateSource();
  }
819370
public void clear() {
    mMap.forEach((key, value) -> {
      onCacheUpdate(key, value.mValue);
      onRemove(key);
    });
    mMap.clear();
  }
540331
def remove(self, builder, model):
        
        column = model.get_qualified_deleted_at_column()

        query = builder.get_query()

        wheres = []
        for where in query.wheres:
            # If the where clause is a soft delete date constraint,
            # we will remove it from the query and reset the keys
            # on the wheres. This allows the developer to include
            # deleted model in a relationship result set that is lazy loaded.
            if not self._is_soft_delete_constraint(where, column):
                wheres.append(where)

        query.wheres = wheres
736947
@RequestMapping(value = "/api/profile/{profileIdentifier}", method = RequestMethod.DELETE)
    public
    @ResponseBody
    HashMap<String, Object> removeFromList(Model model, @PathVariable String profileIdentifier) throws Exception {
        Integer profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);
        logger.info("Want to (preRemove) DELETE on id {}", profileId);
        // TODO: make this remove all clients etc for a profile
        profileService.remove(profileId);
        return Utils.getJQGridJSON(profileService.findAllProfiles(), "profiles");
    }
1331910
public ArrayList filterExternalCacheFragmentList(String cacheName, ArrayList incomingList) {
		InvalidationTableList invalidationTableList = getInvalidationTableList(cacheName);
		try {
			invalidationTableList.readWriteLock.readLock().lock();
			Iterator it = incomingList.iterator();
			while (it.hasNext()) {
				ExternalInvalidation externalCacheFragment = (ExternalInvalidation) it.next();

				if (null == internalFilterExternalCacheFragment(cacheName, invalidationTableList, externalCacheFragment)) {
					if (tc.isDebugEnabled()) {
						Tr.debug(tc, "filterExternalCacheFragmentList(): Filtered OUT cacheName=" + cacheName + " uri=" + externalCacheFragment.getUri());
					}
					it.remove();
				}
			}
			return incomingList;

		} finally {
			invalidationTableList.readWriteLock.readLock().unlock();
		}
	}
1213748
public function flush($model)
    {
        if (! $this->shouldMaintainIndex($model)) {
            return;
        }

        $indexColumn = $this->getIndexColumn($model);

        $this->database
            ->table($model->searchableAs())
            ->update([$indexColumn => null]);
    }
735999
def delete_model(self, model):
        """"""
        if SessionActivity.is_current(sid_s=model.sid_s):
            flash('You could not remove your current session', 'error')
            return
        delete_session(sid_s=model.sid_s)
        db.session.commit()
1301126
@Override
	public void clearCache() {
		entityCache.clearCache(CommerceCountryImpl.class);

		finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}
482177
@Override
	public void clearCache() {
		entityCache.clearCache(CommerceNotificationAttachmentImpl.class);

		finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}
445907
void remove(int row, int column) {
        SparseArrayCompat<TObj> array = mData.get(row);
        if (array != null) {
            array.remove(column);
        }
    }
594268
public void cleanTables() {
        try {
            DefaultTableModel algModel = (DefaultTableModel) jTableAlgorithms.getModel();
            DefaultTableModel strModel = (DefaultTableModel) jTableStreams.getModel();
            int rows = jTableAlgorithms.getRowCount();
            int srow = jTableStreams.getRowCount();
            int trow = this.taskList.size();
            for (int i = 0; i < rows; i++) {
                algModel.removeRow(0);
            }
            for (int i = 0; i < srow; i++) {
                strModel.removeRow(0);
            }
            for (int i = 0; i < trow; i++) {
                this.taskList.remove(0);
            }
            this.taskTableModel.fireTableDataChanged();
        } catch (Exception e) {
            JOptionPane.showMessageDialog(null, "Error al limpiar la tabla.");
        }
    }
241997
@Override
	public void clearCache(CommerceWarehouse commerceWarehouse) {
		entityCache.removeResult(CommerceWarehouseModelImpl.ENTITY_CACHE_ENABLED,
			CommerceWarehouseImpl.class, commerceWarehouse.getPrimaryKey());

		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}