Java对象级别与类级别的同步锁synchronized语法示例

Java中的synchronized关键字提供了一种在多线程情况下同步访问共享资源的机制。synchronized关键字有两种用法：对象级别的同步和类级别的同步。

对象级别的同步锁

对象级别的同步锁可以保证同一时刻只有一个线程能够访问该对象的synchronized方法或代码块。对象级别的同步锁可以使用对象的实例作为锁，即synchronized(obj){...}。

例如：

public class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

上述代码中，increment()和getCount()方法都加上了synchronized关键字，因此在方法内部访问count变量时，会获得当前对象的锁。这样一来，即使多个线程同时调用Counter对象的方法，也只有一个线程能够访问count变量。

类级别的同步锁

类级别的同步锁是在类加载时对整个类加锁，即同一时刻只能有一个线程能够访问该类的synchronized方法或代码块。类级别的同步锁可以使用class对象作为锁，即synchronized(Counter.class){...}。

例如：

public class Counter {
    private static int count = 0;

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

    public static synchronized int getCount() {
        return count;
    }
}

上述代码中，increment()和getCount()方法都加上了synchronized关键字，并且都使用了class对象作为锁，因此在方法内部访问count变量时，会获得Counter.class的锁。这样一来，即使多个线程同时调用Counter类的静态方法，也只有一个线程能够访问count变量。

以上是Java对象级别与类级别的同步锁synchronized语法示例的完整攻略，下面是两条用例说明：

示例一

public class Test {
    public static void main(String[] args) {
        final Counter counter = new Counter();

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

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                counter.increment();
            }
        });

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

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

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

上述代码中，Test类创建了两个线程，分别对Counter对象的increment方法进行10次累加。由于increment方法使用了对象级别的同步锁，因此同一时刻只有一个线程能够访问Counter对象的increment方法。程序最终输出结果为20。

示例二

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

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                Counter.increment();
            }
        });

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

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

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

上述代码中，Test类创建了两个线程，分别对Counter类的静态方法increment进行10次累加。由于increment方法使用了类级别的同步锁，因此同一时刻只有一个线程能够访问Counter类的increment方法。程序最终输出结果为20。

以上就是Java对象级别与类级别的同步锁synchronized语法示例的完整攻略。