创建两个线程，一个线程负责递增一个共享变量的值，另一个线程负责递减该变量的值。每个线程执行一定次数后（比如1000次），打印出该变量的当前值。

创建这样的线程场景通常需要使用Java的并发库，如`Thread`类和`synchronized`关键字来处理共享资源的同步问题，防止数据竞争。这里是一个简单的示例：

public class SharedVariable {
    private int value = 0;
    private final Object lock = new Object();

    public synchronized void increment() {
        value++;
        notify();
    }

    public synchronized void decrement() {
        value--;
        notify();
    }

    public int getValue() {
        return value;
    }
}

public class IncrementDecrementTask implements Runnable {
    private SharedVariable sharedVar;
    private int count;

    public IncrementDecrementTask(SharedVariable var, int cnt) {
        this.sharedVar = var;
        this.count = cnt;
    }

    @Override
    public void run() {
        for (int i = 0; i < count; i++) {
            if (i % 2 == 0) { // 如果是偶数次，递增
                try {
                    sharedVar.increment();
                    Thread.sleep(1); // 模拟一些耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else { // 如果是奇数次，递减
                sharedVar.decrement();
                Thread.sleep(1);
            }
            System.out.println("Thread " + Thread.currentThread().getId() + ", Value: " + sharedVar.getValue());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SharedVariable shared = new SharedVariable();
        Thread incrementer = new Thread(new IncrementDecrementTask(shared, 1000));
        Thread decrementer = new Thread(new IncrementDecrementTask(shared, 1000));

        incrementer.start();
        decremented.start();

        incrementer.join();
        decremented.join();
    }
}

在这个例子中，我们创建了一个`SharedVariable`类，它有一个私有的计数器`value`和一个锁对象。`increment()`和`decrement()`方法都用了`synchronized`修饰，以保证对`value`的操作是原子性的。

`IncrementDecrementTask`实现了`Runnable`接口，两个线程分别执行递增和递减任务，并在每次改变完`value`后打印结果。

注意，这里使用了`notify()`和`sleep()`来模拟同步过程，实际生产环境中可能会使用更复杂的同步机制如`Semaphore`或`CountDownLatch`。