Java同步的粒度

在Java中，同步(synchronization)是一种用于控制多个线程访问共享资源的机制，以防止数据不一致和线程干扰。Java同步可以作用于不同的粒度层次，主要包括以下几种：

1. 方法级同步(Method-Level Synchronization)

   • 同步方法(Synchronized Methods): 在方法声明中使用synchronized关键字，使得整个方法都是同步的。当一个线程访问某个对象的同步方法时，其他线程无法同时访问该对象的所有同步方法。
    

   public synchronized void method() {
       // critical section
   }
   

   • 静态同步方法(Static Synchronized Methods): 类似于同步方法，但是锁定的是类的Class对象，而不是实例对象，这意味着两个线程不能同时执行同一个类的任何静态同步方法。

   public static synchronized void staticMethod() {
       // critical section
   }
   

2. 块级同步(Block-Level Synchronization)

   • 同步块(Synchronized Blocks): 可以减小同步的粒度，仅在特定的代码块上同步。同步块可以指定锁定一个特定的对象，而不是整个方法。

   public void method() {
       // other operations
       synchronized (this) {
           // critical section
       }
       // other operations
   }
   

   • 静态同步块(Static Synchronized Blocks): 使用静态同步块可以锁定类的Class对象，这与静态同步方法类似，但是可以减小同步的范围到代码块。

   public void staticMethod() {
       synchronized (ClassName.class) {
           // critical section
       }
   }
   

3. 对象级同步(Object-Level Synchronization)

   • 锁定对象: 可以选择锁定任何对象作为同步的锁，这提供了更细粒度的控制。不同的线程可以同时访问同一对象的不同同步块，只要它们锁定的是不同的对象。

   public void method() {
       Object lock = new Object();
       synchronized (lock) {
           // critical section
       }
   }
   

4. 类级同步(Class-Level Synchronization)

   • 锁定类对象: 当使用类对象作为锁时，它会影响类的所有实例，因为类的Class对象是唯一的。

   public void method() {
       synchronized (MyClass.class) {
           // critical section
       }
   }
   

5. 细粒度的锁定(Granular Locking)

   • 多个锁: 为不同的资源使用不同的锁可以减少锁竞争，提升性能。例如，如果一个类中有两个独立的同步区域，那么可以为这两个区域使用两个不同的锁对象。

   public void method() {
       Object lockA = new Object();
       Object lockB = new Object();
       
       synchronized (lockA) {
           // critical section A
       }
       
       synchronized (lockB) {
           // critical section B
       }
   }
   

6. 锁优化(Lock Optimization)

   • 锁消除(Lock Elision): JVM在运行时可以判断某些代码块实际上不需要同步，因此可以消除这些锁，即使代码中显式地声明了同步。
   • 锁粗化(Lock Coarsening): 如果JVM检测到连续的锁操作只是对同一个对象的锁定，它可能会将这些操作合并为一次锁定，以减少锁的开销。
   • 轻量级锁(Lightweight Locking)和偏向锁(Biased Locking): 这些是JVM层面的锁优化技术，可以在没有竞争的情况下减少锁的开销。

总之，Java同步的粒度从粗到细提供了不同级别的锁定方式，可以根据实际情况和需求来选择最合适的同步策略。粒度越细，潜在的并发度越高，但编程的复杂性和出错的可能性也相应增加。因此，设计同步策略时需要在性能与复杂性之间做出权衡。

以下是Java中不同同步粒度的一些具体例子：

方法级同步

同步实例方法

public class Counter {
    private int count = 0;
    
    // 同步整个方法
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

在这个例子中，increment 和 getCount 方法都是同步的，这意味着当一个线程进入这些方法时，其他线程必须等待。

同步静态方法

public class StaticCounter {
    private static int staticCount = 0;
    
    // 同步静态方法
    public static synchronized void staticIncrement() {
        staticCount++;
    }
    
    public static synchronized int getStaticCount() {
        return staticCount;
    }
}

这里，staticIncrement 和 getStaticCount 是静态同步方法，它们锁定的是类的Class对象。

块级同步

同步代码块

public class BlockCounter {
    private int count = 0;
    private final Object lock = new Object();
    
    public void increment() {
        // 同步代码块，锁定特定对象
        synchronized (lock) {
            count++;
        }
    }
}

在上面的例子中，我们只同步了修改count变量的那部分代码。

静态同步块

public class StaticBlockCounter {
    private static int staticCount = 0;
    private static final Object staticLock = new Object();
    
    public static void staticIncrement() {
        // 同步静态代码块，锁定Class对象
        synchronized (StaticBlockCounter.class) {
            staticCount++;
        }
    }
}

这个例子中使用静态同步块来锁定类的Class对象。

对象级同步

用不同的对象作为锁

public class FineGrainedCounter {
    private int countA = 0;
    private int countB = 0;
    private final Object lockA = new Object();
    private final Object lockB = new Object();
    
    public void incrementA() {
        synchronized (lockA) {
            countA++;
        }
    }
    
    public void incrementB() {
        synchronized (lockB) {
            countB++;
        }
    }
}

在这个例子中，incrementA 和 incrementB 方法使用了不同的锁对象，这允许它们可以并行执行，提高了效率。

类级同步

锁定类的Class对象

public class ClassLockCounter {
    private static int count = 0;
    
    public void increment() {
        // 同步代码块，锁定整个类
        synchronized (ClassLockCounter.class) {
            count++;
        }
    }
}

这里用类的Class对象作为锁，这样的锁定是针对类的所有实例的。

其他同步技术

使用java.util.concurrent.locks.Lock

Java提供了更为灵活的锁机制，通过java.util.concurrent.locks.Lock接口及其实现类（如 ReentrantLock）提供了更高级的锁功能。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockCounter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

在这个例子中，increment 方法使用了ReentrantLock来实现同步，这种锁提供了比synchronized关键字更细粒度的锁定控制，包括尝试加锁、定时锁等功能。

以上例子展示了不同粒度的同步方式，在实际的多线程编程中，应根据实际需要选择最合适的同步机制。记住，大多数情况下，使用较高级别的并发工具（如java.util.concurrent包中的组件）可能更为安全和高效。