在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等）来提供更细粒度的控制。