Android 中自动同步的机制的简单的demo，例如订单同步，商品同步，会员同步，操作同步

说白了，自动同步就是几个线程自动的过一段时间执行一次看看服务器端有没有更新而已。也就是每过一段时间执行一次线程。
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
0：自动同步就是每过一段时间和服务器进行一次请求而已，也就是执行一次线程的程序，线程里面进行网络请求。

这里的demo，只是demo了执行线程，里面没有网络请求，

还有这里为了方便是设置了一个按钮，其实可以直接放在onCreate方法里面的。

Android 中自动同步的机制的简单的demo0

1：其实应该是要有网络请求的，网络请求后，然后保存这次请求的时间，作为最后的时间lastTime，保存到特定给的表中，
下一次请求的时候查找这个表，将这个最后的时间lastTime发送给服务器，服务器会查找该时间点之后个数据给我们。

一定要记住的是要保存这个lastTime

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

MainActivity:

这里为了方便是设置了一个按钮，其实可以直接放在onCreate方法里面的。

package tech.androidstudio.autosync;

import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;

import tech.androidstudio.autosync.schedule.ServiceContext;

public class MainActivity extends AppCompatActivity {
    private Handler mHandler;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mHandler = new Handler();
    }

    public void syncBtn(View view) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                ServiceContext.getScheduleEngine().start();
            }
        });
    }
}

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="tech.androidstudio.autosync.MainActivity">

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="自动同步按钮"
        android:onClick="syncBtn"/>
</RelativeLayout>

接口：

package tech.androidstudio.autosync.schedule.engine;

/**
 * Created by Kodulf on 2016/7/5.
 */
public interface Schedule {
    public void startSync();
}

引擎：

在同步engine 的线程（每30分钟执行一次）启动的时候会去启动另外四个同步的线程，这些线程都是有固定的更新的时间的

package tech.androidstudio.autosync.schedule.engine;

import android.util.Log;

import tech.androidstudio.autosync.schedule.CustomerSchedule;
import tech.androidstudio.autosync.schedule.ServiceContext;

/**
 * Created by Kodulf on 2016/7/5.
 */
public class ScheduleEngine {

    private Thread mScheduleEngine;

    public void start(){
        if(mScheduleEngine ==null){
            mScheduleEngine = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        Log.d("kodulf","同步引擎启动了 "+Thread.currentThread().getName());

                        startSync(ServiceContext.getOperatorSchedule());
                        startSync(ServiceContext.getCustomerSchedule());
                        startSync(ServiceContext.getRetailItemSchedule());
                        startSync(ServiceContext.getRetailOrderSchedule());
                        try {
                            Thread.sleep(30*60*1000);
                        } catch (InterruptedException e) {
                            try {
                                Thread.sleep(30*60*1000);
                            } catch (InterruptedException e1) {
                                e1.printStackTrace();
                            }
                            e.printStackTrace();
                        }
                    }
                }
            });
            //注意start要在这里
            mScheduleEngine.start();
        }
        //start 不能在这里,不然会报错
        //mScheduleEngine.start();

        if(Thread.State.TERMINATED.equals(mScheduleEngine.getState())){
            mScheduleEngine.start();
        }


    }

    public void startSync(Schedule schedule){
        schedule.startSync();
    }
}

ServiceContext：

package tech.androidstudio.autosync.schedule;

import tech.androidstudio.autosync.schedule.engine.ScheduleEngine;

/**
 * Created by Kodulf on 2016/7/6.
        */
public class ServiceContext {

    private static OperatorSchedule operatorSchedule = new OperatorSchedule();
    private static RetailItemSchedule retailItemSchedule = new RetailItemSchedule();
    private static RetailOrderSchedule retailOrderSchedule = new RetailOrderSchedule();
    private static CustomerSchedule customerSchedule = new CustomerSchedule();
    private static ScheduleEngine scheduleEngine = new ScheduleEngine();

    public static ScheduleEngine getScheduleEngine() {
        return scheduleEngine;
    }

    public static OperatorSchedule getOperatorSchedule() {
        return operatorSchedule;
    }

    public static RetailItemSchedule getRetailItemSchedule() {
        return retailItemSchedule;
    }

    public static RetailOrderSchedule getRetailOrderSchedule() {
        return retailOrderSchedule;
    }

    public static CustomerSchedule getCustomerSchedule() {
        return customerSchedule;
    }
}

会员同步：

package tech.androidstudio.autosync.schedule;

import android.util.Log;

import tech.androidstudio.autosync.schedule.engine.Schedule;

/**
 * Created by Kodulf on 2016/7/5.
 * 会员的同步
 */
public class CustomerSchedule implements Schedule {
    private Thread customerScheduleThread;
    @Override
    public void startSync() {
        if(customerScheduleThread ==null){
            customerScheduleThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        Log.d("kodulf","客户的同步开始了 30分钟一次"+Thread.currentThread().getName());
                        //TODO 网络请求，记住保存lastTime，就是最后更新的时间，保存到特定的表中，
                        // TODO 注意不同的同步线程的lastTime肯定是表中的不同的数据

                        try {
                            Thread.sleep(30*60*1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            //注意start要在这里
            customerScheduleThread.start();
        }
        //start 不能在这里,不然会报错
        //customerScheduleThread.start();
        if(Thread.State.TERMINATED.equals(customerScheduleThread.getState())){
            customerScheduleThread.start();
        }
    }
}

操作同步：

package tech.androidstudio.autosync.schedule;

import android.util.Log;

import tech.androidstudio.autosync.schedule.engine.Schedule;

/**
 * Created by Kodulf on 2016/7/5.
 * 操作的同步
 */
public class OperatorSchedule implements Schedule {
    private Thread operatorScheduleThread;
    @Override
    public void startSync() {
        if(operatorScheduleThread ==null){
            operatorScheduleThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        Log.d("kodulf","操作的同步开始了 一分钟同步一次"+Thread.currentThread().getName());
                        //TODO 网络请求，记住保存lastTime，就是最后更新的时间，保存到特定的表中，
                        // TODO 注意不同的同步线程的lastTime肯定是表中的不同的数据

                        try {
                            Thread.sleep(60*1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            //注意start要在这里
            operatorScheduleThread.start();
        }
        //start 不能在这里,不然会报错
        //operatorScheduleThread.start();
        if(Thread.State.TERMINATED.equals(operatorScheduleThread.getState())){
            operatorScheduleThread.start();
        }
    }
}

商品同步：

package tech.androidstudio.autosync.schedule;

import android.util.Log;

import tech.androidstudio.autosync.schedule.engine.Schedule;

/**
 * Created by Kodulf on 2016/7/5.
 * 商品的同步
 */
public class RetailItemSchedule implements Schedule {
    private Thread retailItemScheduleThread;
    @Override
    public void startSync() {
        if(retailItemScheduleThread ==null){
            retailItemScheduleThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        Log.d("kodulf","商品的同步开始了，30分钟一次 "+Thread.currentThread().getName());
                        //TODO 网络请求，记住保存lastTime，就是最后更新的时间，保存到特定的表中，
                        // TODO 注意不同的同步线程的lastTime肯定是表中的不同的数据

                        try {
                            Thread.sleep(30*60*1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            //注意start要在这里
            retailItemScheduleThread.start();
        }
        //start 不能在这里,不然会报错
        //retailItemScheduleThread.start();
        if(Thread.State.TERMINATED.equals(retailItemScheduleThread.getState())){
            retailItemScheduleThread.start();
        }
    }
}

订单同步：

这里在订单同步中还测试了一下CountDownLatch的使用，
latch.await(30*60*1000, TimeUnit.MICROSECONDS);的方法就是等待latch的countDown，如果没有发生countDown，那么里面的参数就是等待多长时间后自动结束
                           

package tech.androidstudio.autosync.schedule;

import android.util.Log;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import tech.androidstudio.autosync.schedule.engine.Schedule;

/**
 * Created by Kodulf on 2016/7/5.
 * 订单同步
 */
public class RetailOrderSchedule implements Schedule {
    private Thread retailOrderScheduleThread;
    @Override
    public void startSync() {
        if(retailOrderScheduleThread ==null){
            retailOrderScheduleThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        final CountDownLatch latch = new CountDownLatch(1);
                        Log.d("kodulf","订单的latch countDown 之前"+Thread.currentThread().getName());
                        //TODO 网络请求，记住保存lastTime，就是最后更新的时间，保存到特定的表中，
                        // TODO 注意不同的同步线程的lastTime肯定是表中的不同的数据

                        //3482*100 毫秒数，大概是348秒，也就是5分钟多一点
                        for (long i = 0; i < 100000000000l; i++) {
                            if(i==99999999999l){
                                latch.countDown();
                                Log.d("kodulf","订单的latch countDown 之后"+Thread.currentThread().getName());
                            }
                        }
                        try {
                            Log.d("kodulf","订单的Latch执行之前"+Thread.currentThread().getName());
                            //TODO latch.await()的方法就是等待latch的countDown，如果没有发生countDown，
                            // TODO 那么里面的参数就是等待多长时间后自动结束
                            latch.await(30*60*1000, TimeUnit.MICROSECONDS);
                            Log.d("kodulf","订单的Latch执行之后"+Thread.currentThread().getName());

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

                        Log.d("kodulf","订单的同步开始了，1分钟一次 "+Thread.currentThread().getName());

                        try {
                            Thread.sleep(60*1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }
                }
            });
            //注意start要在这里
            retailOrderScheduleThread.start();
        }
        //start 不能在这里,不然会报错
        //retailOrderScheduleThread.start();
        if(Thread.State.TERMINATED.equals(retailOrderScheduleThread.getState())){
            retailOrderScheduleThread.start();
        }
    }
}

在同步engine 的线程（每30分钟执行一次）启动的时候会去启动另外四个同步的线程，这些线程都是有固定的更新的时间的