在Java中，"++"操作符(遞增操作符)本身是原子操作，也就是說它在單線程環境下是線程安全的。原子操作是指一個操作在執行過程中不會被中斷的操作，要么它執行完畢，要么它不執行。但是需要注意的是，當多個線程同時對同一個變量進行遞增操作時，就不再是線程安全的，可能會出現競態條件(race condition)問題。

　　下面是一個簡單的示例代碼來演示多線程環境下遞增操作的線程安全問題：

public class ThreadSafetyDemo {

    private static int counter = 0;

    public static void main(String[] args) {
        int numberOfThreads = 5;
        Thread[] threads = new Thread[numberOfThreads];

        for (int i = 0; i < numberOfThreads; i++) {
            threads[i] = new IncrementThread();
            threads[i].start();
        }

        // Wait for all threads to finish
        for (int i = 0; i < numberOfThreads; i++) {
            try {
                threads[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

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

    static class IncrementThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 100000; i++) {
                counter++;
            }
        }
    }
}

　　在上面的代碼中，我們創建了5個線程，每個線程都會對全局變量counter執行100000次遞增操作。由于counter++不是原子操作，當多個線程同時對counter進行遞增時，會出現競態條件，導致最終結果可能小于預期的500000(5個線程每個線程增加了100000次)。

　　為了保證線程安全，我們可以使用AtomicInteger類，它提供了原子操作的方式來處理這種情況：

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadSafetyDemo {

    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        int numberOfThreads = 5;
        Thread[] threads = new Thread[numberOfThreads];

        for (int i = 0; i < numberOfThreads; i++) {
            threads[i] = new IncrementThread();
            threads[i].start();
        }

        // Wait for all threads to finish
        for (int i = 0; i < numberOfThreads; i++) {
            try {
                threads[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("Final counter value: " + counter.get());
    }

    static class IncrementThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 100000; i++) {
                counter.incrementAndGet();
            }
        }
    }
}

　　在上述示例中，我們使用AtomicInteger來替代普通的int類型，AtomicInteger的incrementAndGet()方法確保了遞增操作的原子性，避免了競態條件問題。運行上面的代碼，最終的counter值應該為500000，符合預期結果。