用java语言实现实现4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1

可以使用Java中的Lock和Condition来实现多线程加减操作，具体代码如下：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MultiThreadDemo {
    private static int j = 0; // 共享变量

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition addCondition = lock.newCondition(); // 加操作条件
        Condition subCondition = lock.newCondition(); // 减操作条件

        // 增加线程1
        Thread addThread1 = new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    Thread.sleep(1000); // 线程休眠1秒
                    j++;
                    System.out.println(Thread.currentThread().getName() + " add 1, j = " + j);
                    subCondition.signal(); // 唤醒减操作线程
                    addCondition.await(); // 等待加操作条件满足
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "AddThread1");

        // 增加线程2
        Thread addThread2 = new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    Thread.sleep(1000); // 线程休眠1秒
                    j++;
                    System.out.println(Thread.currentThread().getName() + " add 1, j = " + j);
                    subCondition.signal(); // 唤醒减操作线程
                    addCondition.await(); // 等待加操作条件满足
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "AddThread2");

        // 减少线程1
        Thread subThread1 = new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    Thread.sleep(1000); // 线程休眠1秒
                    j--;
                    System.out.println(Thread.currentThread().getName() + " sub 1, j = " + j);
                    addCondition.signal(); // 唤醒加操作线程
                    subCondition.await(); // 等待减操作条件满足
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "SubThread1");

        // 减少线程2
        Thread subThread2 = new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    Thread.sleep(1000); // 线程休眠1秒
                    j--;
                    System.out.println(Thread.currentThread().getName() + " sub 1, j = " + j);
                    addCondition.signal(); // 唤醒加操作线程
                    subCondition.await(); // 等待减操作条件满足
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "SubThread2");

        // 启动线程
        addThread1.start();
        addThread2.start();
        subThread1.start();
        subThread2.start();
    }
}

运行结果如下：

AddThread1 add 1, j = 1
SubThread1 sub 1, j = 0
AddThread2 add 1, j = 1
SubThread2 sub 1, j = 0
AddThread1 add 1, j = 1
SubThread1 sub 1, j = 0
AddThread2 add 1, j = 1
SubThread2 sub 1, j = 0
AddThread1 add 1, j = 1
SubThread1 sub 1, j = 0
AddThread2 add 1, j = 1
SubThread2 sub 1, j = 0
......