Java中有两个运行的线程A、B,他们中分别对应两个数字a、b，线程每运行一次两个数据都加1，如何保证线程在运行过程中 a总是大于b?

可以通过使用synchronized关键字来实现，具体实现方式如下：

1. 在A和B线程的共享代码中使用synchronized保证线程安全。

2. 在A线程中使用while循环，当a小于或等于b时，线程进入等待状态；在B线程中同样使用while循环，当a大于b时，线程进入等待状态。

3. 当a被A线程加1时，唤醒B线程；当b被B线程加1时，唤醒A线程。

4. 循环执行上述步骤，直到满足需求为止。

以下是示例代码：

public class ThreadTest {
    private static int a = 0;
    private static int b = 0;
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread A = new Thread(() -> {
            while(true){
                synchronized(lock){
                    a++;
                    System.out.println("A: a = " + a + ", b = " + b);
                    if(a > b){
                        lock.notify();
                    }else{
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });

        Thread B = new Thread(() -> {
            while(true){
                synchronized(lock){
                    b++;
                    System.out.println("B: a = " + a + ", b = " + b);
                    if(a <= b){
                        lock.notify();
                    }else{
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });

        A.start();
        B.start();
    }
}

以上代码中，我们使用一个Object对象作为锁，当一个线程持有锁时，另一个线程无法执行共享代码，直到锁被释放。当a小于或等于b时，A线程进入等待状态，释放锁，让B线程执行；当a大于b时，B线程进入等待状态，释放锁，让A线程执行。当一个线程完成加1的操作时，唤醒另一个线程，使其继续执行。通过这种方式，我们可以保证a总是大于b。