使用Java线程的异步调用

我的应用程序中有两个方法，它们希望一个接一个地执行

removeAllNonSyncedData();
getFullDbFromREST();

第一种方法是

removeAllNonSyncedData（）

，它从数据库中删除所有非同步数据

清除所有数据后，我要执行

getFullDbFromREST（）

private void removeAllNonSyncedData（）{
试一试{
ContentResolver cr=getContentResolver（）；
ContentProviderHelp=新ContentProviderHelp（）；
ObjectPropertyValueTable ObjectPropertyValueTable=新的ObjectPropertyValueTable（帮助器）；
ObjectPropertyValueAuditTrailTable ObjectPropertyValueAuditTrailTable=新的ObjectPropertyValueAuditTrailTable（帮助器）；
PhotoInfoTable PhotoInfoTable=新的PhotoInfoTable（助手）；
PropertyDefinitionTable PropertyDefinitionTable=新的PropertyDefinitionTable（助手）；
SyncManagerTable SyncManagerTable=新的SyncManagerTable（助手）；
cr.delete（ObjectPropertyValueTable.getContentURI（），ObjectPropertyValueTable.SyncStatus+“1”，null）；
cr.delete（ObjectPropertyValueAuditTrailTable.getContentURI（），null，null）；
cr.delete（SyncManagerTable.getContentURI（），null，null）；
cr.delete（PhotoInfoTable.getContentURI（），PhotoInfoTable.SyncStatus+“1”，null）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}

---

第一个方法完成后（数据完全从数据库中清除），如何执行第二个方法？

好吧，这是默认情况，除非异步调用第一个方法。否则，方法总是一个接一个地执行。

我已经使用这样的线程实现了这种情况 我想写一个文件后，完成写，然后我想读一个文件，所以我让两个线程读写像下面的方式和用户等待和通知功能

public  Object isWrite=new Object();
    private class WriteThread extends Thread {
        @Override
        public void run() {
            super.run();
            synchronized (isWrite){
                        //Do something as you want
                        isWrite.wait();
        }
}
}

    private class ReadThread extends Thread {
        @Override
        public void run() {
            super.run();
            synchronized (isWrite){
                      //Do something as you want                         
                      isWrite.notify();

        }
}
}

        //Calling of write thread then read thread.
        try {
            WriteThread mWriteThread=new WriteThread();
            mWriteThread.start();

            mReadThread = new ReadThread();
            mReadThread.start();

        } catch (SecurityException e) {
            e.printStackTrace();
        }

public  Object isWrite=new Object();
    private class WriteThread extends Thread {
        @Override
        public void run() {
            super.run();
            synchronized (isWrite){
                        //Do something as you want
                        isWrite.wait();
        }
}
}

    private class ReadThread extends Thread {
        @Override
        public void run() {
            super.run();
            synchronized (isWrite){
                      //Do something as you want                         
                      isWrite.notify();

        }
}
}

        //Calling of write thread then read thread.
        try {
            WriteThread mWriteThread=new WriteThread();
            mWriteThread.start();

            mReadThread = new ReadThread();
            mReadThread.start();

        } catch (SecurityException e) {
            e.printStackTrace();
        }