Synchronized锁升级的过程

在Java中，synchronized关键字是一种内置的同步机制，它可以用来控制多个线程对共享资源的访问。为了避免多线程环境下的竞态条件，Java虚拟机（JVM）实现了多种锁机制，这些锁机制会根据锁的竞争程度自动升级或降级。

无锁（无锁状态）

在对象刚被创建时，它处于无锁状态，也称为“无锁（无偏向）”状态。在这个阶段，任何线程都可以访问这个对象，因为没有进行同步控制。

public class Point {
    private int value;

    public void increase() {
        value++;
    }
}

偏向锁

当一个线程访问了这个对象，并且没有其他线程竞争时，对象会进入偏向锁状态。偏向锁会记录获取它的线程ID，这样下次该线程再次访问时，就不需要进行同步操作了。

public class Point {
    private int value;

    public synchronized void increase() {
        value++;
    }
}

在这个例子中，如果increase方法总是由同一个线程调用，那么在第一次调用后，这个对象就会进入偏向锁状态。

轻量级锁

如果多个线程尝试访问同一个对象，那么偏向锁就会升级为轻量级锁。轻量级锁使用CAS（Compare-And-Swap）操作来尝试获取锁，如果获取失败，线程会进行自旋等待，直到锁被释放。

public class Point {
    private volatile int value;

    public void increase() {
        synchronized(this) {
            value++;
        }
    }
}

在这个例子中，如果多个线程同时调用increase方法，那么对象可能会进入轻量级锁状态。

重量级锁

如果轻量级锁自旋一定次数后仍然无法获取锁，那么它就会升级为重量级锁。重量级锁会阻塞那些获取失败的线程，直到锁被释放。

public class Point {
    private int value;

    public synchronized void increase() {
        value++;
    }
}

在这个例子中，如果多个线程同时调用increase方法，那么对象最终可能会进入重量级锁状态。

安全点

安全点是JVM执行垃圾回收（GC）时，所有线程都会暂停的位置。这些位置通常是方法调用、方法返回、异常抛出、循环末尾等。偏向锁的撤销通常在安全点进行，以避免在撤销过程中发生竞争。

示例代码

下面是一个简单的示例，展示了如何使用synchronized关键字来同步方法：

public class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

public class TestCounter {
    public static void main(String[] args) {
        final Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });

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

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

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

在这个例子中，Counter类有一个increment方法，它使用synchronized关键字来确保线程安全。TestCounter类创建了两个线程，它们同时对Counter对象的count属性进行增加操作。由于increment方法是同步的，所以最终的count值应该是20000。

通过以上示例，我们可以看到synchronized关键字如何帮助我们实现线程安全的同步控制。在实际应用中，锁的升级和降级是由JVM自动管理的，我们只需要关注如何正确地使用同步机制即可。