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

下面是一个示例程序，使用Java中的ReentrantLock来保证线程安全性：

import java.util.concurrent.locks.ReentrantLock;

public class ThreadExample {
    private static int j = 0;
    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread incrementThread1 = new IncrementThread();
        Thread incrementThread2 = new IncrementThread();
        Thread decrementThread1 = new DecrementThread();
        Thread decrementThread2 = new DecrementThread();

        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);
    }

    static class IncrementThread extends Thread {
        public void run() {
            for (int i = 0; i < 100000; i++) {
                lock.lock();
                try {
                    j++;
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    static class DecrementThread extends Thread {
        public void run() {
            for (int i = 0; i < 100000; i++) {
                lock.lock();
                try {
                    j--;
                } finally {
                    lock.unlock();
                }
            }
        }
    }
}

在这个示例程序中，我们创建了4个线程，其中两个是IncrementThread，另外两个是DecrementThread。每个线程都会对共享变量j进行操作，增加或减少1。为了确保线程安全性，我们使用了ReentrantLock来实现互斥访问。在每个线程的run方法中，我们首先获取锁，然后对j进行操作，最后释放锁。这样可以确保每次只有一个线程能够访问j，从而避免了竞态条件的发生。

在main方法中，我们启动了四个线程，并使用join方法等待它们全部执行完毕。最后，我们输出j的最终值，以验证程序的正确性