java类锁与对象锁的区别

Java中的类锁和对象锁都是用于同步访问共享资源的方法，但它们的使用方式和范围有所不同。下面通过两个Java代码案例来详细解释它们之间的区别。

类锁（Class Lock）：对类的静态成员进行同步访问的一种机制

类锁是对类的静态成员进行同步访问的一种机制。当一个线程进入一个类的静态同步方法或静态同步代码块时，它会获取该类的类锁。只有当类锁被释放后，其他线程才能再次获取该类锁并进入静态同步方法或静态同步代码块。

以下是一个使用类锁的Java代码案例：

public class ClassLockExample {
    static int sharedResource = 10;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (ClassLockExample.class) {
                try {
                    System.out.println("Thread1: " + sharedResource);
                    sharedResource = 20;
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("Thread1 released class lock");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (ClassLockExample.class) {
                try {
                    System.out.println("Thread2: " + sharedResource);
                    sharedResource = 30;
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("Thread2 released class lock");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

在这个例子中，sharedResource 是被两个线程共享的静态变量。thread1 和 thread2 分别尝试修改这个变量的值。由于它们都使用了类锁（synchronized关键字作用于ClassLockExample.class），所以它们会互斥地访问共享资源。

对象锁（Object Lock）：是对某个对象的实例成员进行同步访问的一种机制

对象锁是对某个对象的实例成员进行同步访问的一种机制。当一个线程进入一个对象的实例同步方法或实例同步代码块时，它会获取该对象的锁。只有当对象锁被释放后，其他线程才能再次获取该对象锁并进入实例同步方法或实例同步代码块。

以下是一个使用对象锁的Java代码案例：

public class ObjectLockExample {
    static class SharedResource {
        int value = 10;
    }

    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();
        Thread thread1 = new Thread(() -> {
            synchronized (sharedResource) {
                try {
                    System.out.println("Thread1: " + sharedResource.value);
                    sharedResource.value = 20;
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("Thread1 released object lock");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (sharedResource) {
                try {
                    System.out.println("Thread2: " + sharedResource.value);
                    sharedResource.value = 30;
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("Thread2 released object lock");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

在这个例子中，sharedResource 是被两个线程共享的一个对象实例。thread1 和 thread2 分别尝试修改这个对象的属性值。由于它们都使用了对象锁（synchronized关键字作用于sharedResource），所以它们会互斥地访问共享资源。

总结：

类锁和对象锁的主要区别在于它们保护的范围不同。类锁用于保护类的静态成员，而对象锁用于保护对象的实例成员。在实际编程中，应根据需要选择合适的锁类型来确保线程安全。