Java 同步方法/同步块不'；行不通
我已经尝试了这两种方法：同步方法和同步块在同一个对象上作为锁，以避免同时运行它们，但似乎对我不起作用Java 同步方法/同步块不'；行不通,java,android,synchronized,Java,Android,Synchronized,我已经尝试了这两种方法：同步方法和同步块在同一个对象上作为锁，以避免同时运行它们，但似乎对我不起作用 public class PagingBoundaryCallback extends PagedList.BoundaryCallback<Crypto> { private static final String LOG_TAG = PagingBoundaryCallback.class.getSimpleName(); private static final String
public class PagingBoundaryCallback extends PagedList.BoundaryCallback<Crypto> {
private static final String LOG_TAG = PagingBoundaryCallback.class.getSimpleName();
private static final String TAG_COIN_MARKET_CAP_API = LOG_TAG + CoinMarketCapApi.class.getSimpleName();
private static final String TAG_CRYPTO_COMPARE_API = LOG_TAG + CryptoCompareApi.class.getSimpleName();
private static final int RESULTS_SIZE = 50;
private static final String TO_SYMBOL = "USD";
private static final int FAVOURITE_FALSE = 0;
private static final Object LOCK = new Object();
private CoinMarketCap coinMarketCapApi;
private CryptoCompare cryptoCompareApi;
private CryptoLocalCache cache;
private int resultsFromRank = 1;
private boolean requestingInProgress = false;
private List<CryptoSimple> cryptoSimpleList;
private List<CryptoDetailed> cryptoDetailedList;
private List<Crypto> cryptoList = new ArrayList<>();
public PagingBoundaryCallback(
CoinMarketCap coinMarketCapApi,
CryptoCompare cryptoCompareApi,
CryptoLocalCache cache) {
this.coinMarketCapApi = coinMarketCapApi;
this.cryptoCompareApi = cryptoCompareApi;
this.cache = cache;
}
@Override
public void onZeroItemsLoaded() {
super.onZeroItemsLoaded();
requestAndSaveData();
}
@Override
public void onItemAtEndLoaded(Crypto itemAtEnd) {
super.onItemAtEndLoaded(itemAtEnd);
requestAndSaveData();
}
private void requestAndSaveData() {
if (requestingInProgress) return;
requestingInProgress = true;
requestCryptoSimple();
requestCryptoDetailed();
createCryptoFromResponses(cryptoSimpleList, cryptoDetailedList);
requestingInProgress = false;
}
private void requestCryptoSimple() {
synchronized (LOCK) {
coinMarketCapApi.requestCoins(resultsFromRank, RESULTS_SIZE).enqueue(
new Callback<CryptoSimpleResponse>() {
@Override
public void onFailure(Call<CryptoSimpleResponse> call, Throwable t) {
Log.d(TAG_COIN_MARKET_CAP_API, "failed to get data");
Log.d(TAG_COIN_MARKET_CAP_API, "Unknown error " + t.getMessage());
}
@Override
public void onResponse(Call<CryptoSimpleResponse> call, Response<CryptoSimpleResponse> response) {
Log.d(TAG_COIN_MARKET_CAP_API, "got response: " + response.toString());
if (response.isSuccessful()) {
cryptoSimpleList = new ArrayList<>();
HashMap<String, CryptoSimple> hashMap = response.body().getItems();
for (Map.Entry<String, CryptoSimple> entry : hashMap.entrySet()) {
CryptoSimple cryptoSimple = entry.getValue();
cryptoSimpleList.add(cryptoSimple);
Log.v("CryptoSimple HashMap", cryptoSimple.toString());
}
Log.v("cryptoSimpleListSize", String.valueOf(cryptoSimpleList.size()));
resultsFromRank += RESULTS_SIZE;
} else {
Log.d(TAG_COIN_MARKET_CAP_API, "Unknown error " + response.errorBody().toString());
}
}
}
);
}
}
private void requestCryptoDetailed() {
synchronized (LOCK) {
StringBuilder cryptoSymbol = new StringBuilder(RESULTS_SIZE);
Log.v("cryptoSimpleListSize", String.valueOf(cryptoSimpleList.size()));
for (CryptoSimple item : cryptoSimpleList) {
cryptoSymbol
.append(item.getSymbol())
.append(",");
}
int cryptoSymbolLength = cryptoSymbol.length();
Log.v("cryptoSymbolLength", String.valueOf(cryptoSymbolLength));
String fromSymbol = cryptoSymbol.delete(cryptoSymbolLength - 1, cryptoSymbolLength).toString();
cryptoCompareApi.requestCoins(fromSymbol, TO_SYMBOL).enqueue(new Callback<CryptoDetailedResponse>() {
@Override
public void onResponse(Call<CryptoDetailedResponse> call, Response<CryptoDetailedResponse> response) {
Log.d(TAG_CRYPTO_COMPARE_API, "got response: " + response.toString());
if (response.isSuccessful()) {
cryptoDetailedList = response.body().getList();
} else {
Log.d(TAG_COIN_MARKET_CAP_API, "Unknown error " + response.errorBody().toString());
}
}
@Override
public void onFailure(Call<CryptoDetailedResponse> call, Throwable t) {
Log.d(TAG_CRYPTO_COMPARE_API, "failed to get data");
Log.d(TAG_CRYPTO_COMPARE_API, "Unknown error " + t.getMessage());
}
});
}
}
private void createCryptoFromResponses(List<CryptoSimple> cryptoSimpleList, List<CryptoDetailed> cryptoDetailedList) {
if (cryptoList.size() != 0)
cryptoList.clear();
for (int i = 0; i < cryptoSimpleList.size(); i++) {
Crypto cryptoItem = new Crypto(
cryptoSimpleList.get(i).getId(),
cryptoSimpleList.get(i).getName(),
cryptoSimpleList.get(i).getSymbol(),
cryptoSimpleList.get(i).getRank(),
cryptoDetailedList.get(i).getPrice(),
cryptoDetailedList.get(i).getTime(),
cryptoDetailedList.get(i).getVolume(),
cryptoDetailedList.get(i).getChangePercentage(),
cryptoDetailedList.get(i).getMarketCap(),
FAVOURITE_FALSE
);
cryptoList.add(cryptoItem);
}
if (cryptoList.size() > 0)
cache.insertCoins(cryptoList);
Log.v(LOG_TAG, "Inserted " + String.valueOf(cryptoList.size()) + " to database");
}}
公共类PagingBoundaryCallback扩展了PagedList.BoundaryCallback{
私有静态最终字符串LOG_TAG=PagingBoundaryCallback.class.getSimpleName（）；
私有静态最终字符串TAG_COIN_MARKET_CAP_API=LOG_TAG+CoinMarketCapApi.class.getSimpleName（）；
私有静态最终字符串标记_CRYPTO_COMPARE_API=LOG_标记+CryptoCompareApi.class.getSimpleName（）；
私有静态最终整数结果_SIZE=50；
私有静态最终字符串到_SYMBOL=“USD”；
私有静态最终int\u FALSE=0；
私有静态最终对象锁=新对象（）；
私人CoinMarketCap coinMarketCapApi；
私有密码比较密码比较；
私有加密本地缓存；
private int resultsFromRank=1；
private boolean requestingingprogress=false；
私有列表密码单纯形列表；
私有列表加密详细列表；
私有列表加密列表=新的ArrayList（）；
公共分页边界回调(
CoinMarketCap coinMarketCapApi，
CryptoCompare cryptoCompareApi，
加密本地缓存（缓存）{
this.coinMarketCapApi=coinMarketCapApi；
this.cryptoCompareApi=cryptoCompareApi；
this.cache=cache；
}
@凌驾
ZeroItemsLoaded（）上的公共无效{
super.onZeroItemsLoaded（）；
requestAndSaveData（）；
}
@凌驾
已加载公用项（加密项结束）{
super.OnItemEnd已加载（ItemEnd）；
requestAndSaveData（）；
}
私有void requestAndSaveData（）{
如果（请求进度）返回；
requestingprogress=true；
requestCryptoSimple（）；
requestCryptoDetailed（）；
createCryptoFromResponses（cryptoSimpleList、cryptoDetailedList）；
requestingprogress=false；
}
私有void requestCryptoSimple（）{
已同步（锁定）{
requestCoins（resultsFromRank，结果大小）。排队(
新回调函数（）{
@凌驾
失败时公共无效（调用调用，可丢弃的t）{
Log.d（TAG_COIN_MARKET_CAP_API，“无法获取数据”）；
Log.d（TAG_COIN_MARKET_CAP_API，“未知错误”+t.getMessage（））；
}
@凌驾
公共void onResponse（调用、响应）{
Log.d（TAG_COIN_MARKET_CAP_API，“got response:+response.toString（））；
if（response.issusccessful（））{
cryptoSimpleList=新的ArrayList（）；
HashMap HashMap=response.body（）.getItems（）；
for（Map.Entry:hashMap.entrySet（））{
CryptoSimple CryptoSimple=entry.getValue（）；
cryptoSimpleList.add（cryptoSimple）；
Log.v（“CryptoSimple HashMap”，CryptoSimple.toString（））；
}
Log.v（“cryptoSimpleListSize”，String.valueOf（cryptoSimpleList.size（））；
resultsFromRank+=结果大小；
}否则{
Log.d（TAG_COIN_MARKET_CAP_API，“未知错误”+response.errorBody（）.toString（））；
}
}
}
);
}
}
私有void requestCryptoDetailed（）{
已同步（锁定）{
StringBuilder cryptoSymbol=新的StringBuilder（结果大小）；
Log.v（“cryptoSimpleListSize”，String.valueOf（cryptoSimpleList.size（））；
for（CryptoSimple项：cryptoSimpleList）{
密码符号
.append（item.getSymbol（））
.附加（“，”）；
}
int cryptoSymbolLength=cryptoSymbol.length（）；
Log.v（“cryptoSymbolLength”，String.valueOf（cryptoSymbolLength））；
String fromSymbol=cryptoSymbol.delete（cryptoSymbolLength-1，cryptoSymbolLength）.toString（）；
cryptoCompareApi.requestCoins（fromSymbol，TO_SYMBOL）.enqueue（新回调（））{
@凌驾
公共void onResponse（调用、响应）{
Log.d（TAG_CRYPTO_COMPARE_API，“got response:”+response.toString（））；
if（response.issusccessful（））{
cryptoDetailedList=response.body（）.getList（）；
}否则{
Log.d（TAG_COIN_MARKET_CAP_API，“未知错误”+response.errorBody（）.toString（））；
}
}
@凌驾
失败时公共无效（调用调用，可丢弃的t）{
Log.d（TAG_CRYPTO_COMPARE_API，“无法获取数据”）；
Log.d（TAG_CRYPTO_COMPARE_API，“未知错误”+t.getMessage（））；
}
});
}
}
私有void createCryptoFromResponses（列表cryptoSimpleList、列表cryptoDetailedList）{
如果（cryptoList.size（）！=0）
cryptoList.clear（）；
对于（int i=0；i0）
cache.insertCoins（加密列表）；
Log.v（Log_标记，“插入”+String.valueOf（cryptoList.size（））+“到数据库”）；
}}