设计4个线程其中两个线程每次对j增加1另外两个线程对j每次减少1。考虑到线程的安全性写出程序

下面是一个使用Java编写的线程安全的程序示例：

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

public class ThreadSafetyExample {
    private static int j = 0;
    private static final Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread incrementThread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                increment();
            }
        });

        Thread incrementThread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                increment();
            }
        });

        Thread decrementThread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                decrement();
            }
        });

        Thread decrementThread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                decrement();
            }
        });

        incrementThread1.start();
        incrementThread2.start();
        decrementThread1.start();
        decrementThread2.start();

        try {
            incrementThread1.join();
            incrementThread2.join();
            decrementThread1.join();
            decrementThread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final value of j: " + j);
    }

    private static void increment() {
        lock.lock();
        try {
            j++;
        } finally {
            lock.unlock();
        }
    }

    private static void decrement() {
        lock.lock();
        try {
            j--;
        } finally {
            lock.unlock();
        }
    }
}

在上述示例中，我们使用ReentrantLock来确保多个线程对共享变量j的访问是线程安全的。increment()和decrement()方法都会先获取锁，然后执行相关操作，最后释放锁。这样可以确保同一时间只有一个线程能够修改j的值，从而避免了竞态条件和数据不一致的问题。最后，我们使用join()方法等待所有线程执行完毕，并输出最终的结果