Java 多线程同步技巧，Windows 平台适用！

在 Java 中，多线程编程是很常见的，但多线程编程涉及到线程安全问题，需要使用同步技巧来保证线程安全。本文将介绍 Java 中的几种同步技巧，并提供适用于 Windows 平台的演示代码。

一、synchronized 关键字

synchronized 关键字是 Java 中最常用的同步技巧之一。它可以用来保证同一时刻只有一个线程访问代码块或方法。synchronized 可以用在方法上或代码块上，使用 synchronized 关键字的方法或代码块称为同步方法或同步代码块。

下面是一个使用 synchronized 关键字的示例：

public synchronized void doSomething() {
    // 同步代码块
}

在上面的示例中，使用 synchronized 关键字修饰了 doSomething() 方法，这意味着在同一时刻只有一个线程能够访问该方法。

下面是一个使用 synchronized 关键字的代码块的示例：

synchronized (this) {
    // 同步代码块
}

在上面的示例中，使用 synchronized 关键字修饰了一个代码块，该代码块使用 this 对象作为锁。这意味着在同一时刻只有一个线程能够访问该代码块。

二、ReentrantLock 类

ReentrantLock 类是 Java 中的另一种同步技巧。它提供了比 synchronized 更强大的同步机制，如可中断锁、公平锁等。

下面是一个使用 ReentrantLock 类的示例：

private ReentrantLock lock = new ReentrantLock();

public void doSomething() {
    lock.lock();
    try {
        // 同步代码块
    } finally {
        lock.unlock();
    }
}

在上面的示例中，使用 ReentrantLock 类创建了一个 lock 对象，然后在 doSomething() 方法中使用 lock() 方法获取锁，在 finally 块中使用 unlock() 方法释放锁。

三、Semaphore 类

Semaphore 类是 Java 中的另一种同步技巧。它允许多个线程同时访问共享资源，但限制了同时访问的线程数。

下面是一个使用 Semaphore 类的示例：

private Semaphore semaphore = new Semaphore(3);

public void doSomething() {
    try {
        semaphore.acquire();
        // 同步代码块
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        semaphore.release();
    }
}

在上面的示例中，使用 Semaphore 类创建了一个 semaphore 对象，该对象允许同时访问的线程数为 3。在 doSomething() 方法中，使用 acquire() 方法获取许可证，进入同步代码块，最后使用 release() 方法释放许可证。

四、演示代码

下面是一个适用于 Windows 平台的演示代码，该代码演示了如何使用 synchronized 关键字来保证线程安全：

public class SyncDemo {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        SyncDemo syncDemo = new SyncDemo();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                syncDemo.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                syncDemo.decrement();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(syncDemo.getCount());
    }
}

在上面的代码中，SyncDemo 类有三个方法：increment()、decrement() 和 getCount()。increment() 方法将 count 值加 1，decrement() 方法将 count 值减 1，getCount() 方法返回 count 值。

在 main() 方法中，创建了两个线程 t1 和 t2，分别执行 increment() 和 decrement() 方法。在执行完这两个线程后，输出 count 值。

使用 synchronized 关键字修饰的方法可以保证线程安全，因此在上面的代码中使用了 synchronized 关键字修饰 increment() 和 decrement() 方法。

总结

本文介绍了 Java 中的几种同步技巧，包括 synchronized 关键字、ReentrantLock 类和 Semaphore 类，并提供了适用于 Windows 平台的演示代码。在多线程编程中，使用同步技巧可以保证线程安全，避免出现意外的结果。