Java中的synchronized有几种加锁方式(实例详解)

public class SynchronizedInstanceMethod {  
    public synchronized void doSomething() {  
        // 同步代码块  
        // 同一时间只能有一个线程执行这里的代码  
    }  
    public static void main(String[] args) {  
        SynchronizedInstanceMethod obj = new SynchronizedInstanceMethod();  
        // 创建多个线程访问obj的doSomething方法，它们将串行执行  
        // ...  
    }  
}

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);  
    }  
}

public class SynchronizedStaticMethod {  
    public static synchronized void doSomethingStatic() {  
        // 同步代码块  
        // 同一时间只能有一个线程执行这里的代码  
    }  
    public static void main(String[] args) {  
        // 创建多个线程访问SynchronizedStaticMethod的doSomethingStatic方法，它们将串行执行  
        // ...  
    }  
}

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");  
        // 启动线程...  
        // 等待线程完成...  
        // 输出最终计数...  
        // （与上面的例子类似，但省略了重复的代码）  
    }  
}

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块中的代码将串行执行  
        // ...  
    }  
}

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方法  
        // ...（省略了重复的代码）  
    }  
}