java的synchronized有几种加锁方式

在Java中，synchronized关键字提供了内置的支持来实现同步访问共享资源，以避免并发问题。synchronized主要有三种加锁方式：

1.同步实例方法

当一个实例方法被声明为synchronized时，该方法将同一时间只能被一个线程访问。锁是当前对象实例（即this）。

public class SynchronizedInstanceMethod {
    public synchronized void doSomething() {
        // 同步代码块
        // 同一时间只能有一个线程执行这里的代码
    }  

    public static void main(String[] args) {
        SynchronizedInstanceMethod obj = new SynchronizedInstanceMethod();
        // 创建多个线程访问obj的doSomething方法，它们将串行执行
        // ...
    }
}

当我们创建了两个线程来并发地增加计数器，由于我们使用了synchronized，因此计数器的增加线程是安全的，即使两个线程都在尝试修改同一个共享变量。在同步实例方法中，锁分别是实例对象和类对象。

public class SynchronizedInstanceMethodExample {
    private int count = 0;  

    // 同步实例方法，锁定的是当前对象的实例（this）
    public synchronized void increment() {
        count++;
        System.out.println(Thread.currentThread().getName() + " incremented count to " + count);
    }  

    public static void main(String[] args) {
        final SynchronizedInstanceMethodExample example = new SynchronizedInstanceMethodExample();  

        // 创建两个线程来增加计数器
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        }, "Thread-1");  

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        }, "Thread-2");  

        // 启动线程
        thread1.start();
        thread2.start();  

        // 等待线程完成
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }  

        // 输出最终计数
        System.out.println("Final count: " + example.count);
    }
}

2.同步静态方法

当一个静态方法被声明为synchronized时，该方法将同一时间只能被一个线程访问。锁是Class对象，而不是实例对象。

public class SynchronizedStaticMethod {
    public static synchronized void doSomethingStatic() {
        // 同步代码块
        // 同一时间只能有一个线程执行这里的代码
    }  

    public static void main(String[] args) {
        // 创建多个线程访问SynchronizedStaticMethod的doSomethingStatic方法，它们将串行执行
        // ...
    }
}

当我们创建了两个线程来并发地增加计数器，由于我们使用了synchronized，因此计数器的增加线程是安全的，即使两个线程都在尝试修改同一个共享变量。在同步静态方法中，锁分别也是实例对象和类对象。

public class SynchronizedStaticMethodExample {
    private static int count = 0;  

    // 同步静态方法，锁定的是当前对象的类（Class）对象
    public static synchronized void increment() {
        count++;
        System.out.println(Thread.currentThread().getName() + " incremented static count to " + count);
    }  

    public static void main(String[] args) {
        // 创建两个线程来增加计数器
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        }, "Thread-1");  

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        }, "Thread-2");  

        // 启动线程...
        // 等待线程完成...
        // 输出最终计数...
        // （与上面的例子类似，但省略了重复的代码）
    }
}

3.同步代码块

我们可以使用synchronized关键字来定义一个代码块，而不是整个方法。在这种情况下，你可以指定要获取的锁对象。这提供了更细粒度的同步控制。

public class SynchronizedBlock {
    private final Object lock = new Object(); // 用于同步的锁对象  

    public void doSomething() {
        synchronized (lock) {
            // 同步代码块
            // 同一时间只有一个线程能够执行这里的代码
        }  

        // 这里的代码不受同步代码块的约束
    }  

    public static void main(String[] args) {
        SynchronizedBlock obj = new SynchronizedBlock();
        // 创建多个线程访问obj的doSomething方法，但只有在synchronized块中的代码将串行执行
        // ...
    }
}

在上面的SynchronizedBlock类中，我们创建了一个私有的Object实例lock作为锁对象。当线程进入synchronized (lock)块时，它会尝试获取lock对象的锁。如果锁已经被其他线程持有，那么该线程将被阻塞，直到锁被释放。

当我们创建了两个线程来并发地增加计数器，同步代码块的例子中，我们显式地指定了一个对象作为锁。

public class SynchronizedBlockExample {
    private final Object lock = new Object(); // 用于同步的锁对象
    private int count = 0;  

    // 同步代码块，指定了锁对象
    public void increment() {
        synchronized (lock) {
            count++;
            System.out.println(Thread.currentThread().getName() + " incremented count to " + count);
        }
    }  

    public static void main(String[] args) {
        // 类似于上面的例子，但使用SynchronizedBlockExample的increment方法
        // ...（省略了重复的代码）
    }
}

注意：使用synchronized时应该尽量避免在持有锁的情况下执行耗时的操作，因为这会导致其他等待锁的线程长时间阻塞。同时，过度使用synchronized可能会导致性能下降，因为它会引入线程间的竞争和可能的上下文切换。在设计并发程序时，应该仔细考虑同步的粒度，并可能使用其他并发工具（如ReentrantLock、Semaphore、CountDownLatch等）来提供更细粒度的控制。