Java多线程之synchronized同步代码块详解

什么是synchronized同步代码块？

synchronized 是 Java 中的一个关键字，用来实现多线程的同步。synchronized 有两个作用：一是保证代码块只能由一个线程执行，二是保证该线程执行该代码块期间所需的所有资源都已获取。

具体地说，我们可以使用synchronized关键字来保证线程在执行同步的代码块时是互斥的。在使用时，synchronized需要指定一个锁定对象，当线程希望执行同步代码块时，它必须先获得锁定对象。

示例代码如下：

public class SynchronizedBlockExample {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

在这个例子中，我们定义了一个 SynchronizedBlockExample 类，其中有一个成员变量 count，表示一个计数器。在 increment() 方法中，我们使用 synchronized 关键字来保证 count 的自增操作是原子操作，这样就避免了多个线程同时修改 count 引发的并发问题。

synchronized同步代码块的语法和使用方法

下面是 synchronized 语法的描述：

synchronized (object) {
  // 同步代码块
}

这个语法中，object 是要用来锁住的对象，用于控制并发访问。同时只有获取到 object 锁的线程才能并发访问同步块，其他线程则必须等待。

为了避免死锁问题，应该避免在同一个线程内持有多个锁。如果需要在同一个线程内访问多个锁，应该尽量避免在锁持有期间调用其他同步方法。

下面是一个示例代码：

public class SynchronizedDemo {

    public void doSomething() {
        synchronized (this) {
            // 这里是同步代码块
        }
    }
}

在这个示例中，synchronized 关键字修饰了一个代码块，而 this 则作为锁对象，用于同步并发访问。

避免使用过多的synchronized同步代码块

尽管 synchronized 同步代码块可以帮助我们解决多线程访问共享数据时出现的并发问题，但在使用中也需要注意，过多的 synchronized 会导致性能下降。

为了避免这个问题，我们可以考虑对一些不关键的代码块以及不需要同步的方法移除 synchronized 关键字。同时，也可以使用更轻量级的锁机制，如 ReentrantLock、ReadWriteLock、Atomic 类、线程本地存储（ThreadLocal）等。

示例代码

下面是一个使用 synchronized 的示例，用来统计程序中一个字符串出现的次数：

public class Counter {
    private String str;
    private int count;

    public Counter(String str) {
        this.str = str;
    }

    public int getCount() {
        return count;
    }

    public void count(String text) {
        synchronized(this) {
            int index = text.indexOf(str);
            while (index != -1) {
                count++;
                index = text.indexOf(str, index + 1);
            }
        }
    }
}

在这个示例中，我们使用了 synchronized 同步代码块来保证对计数器的操作是原子操作，从而避免了出现并发问题。同时采用了字符串的 indexOf() 方法来查找指定字符串在文本中出现的位置，并将计数器进行自增操作。

另外，我们还可以使用 AtomicInteger 类来实现线程安全的计数器，示例代码如下：

public class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public int getCount() {
        return count.get();
    }

    public void increment() {
        count.incrementAndGet();
    }
}

在这个示例中，我们使用 AtomicInteger 类来替代了 Count 类中的 int 类型计数器，这个类提供了原子性的操作，可以确保线程安全。其中 incrementAndGet() 方法用来递增计数器，而 getCount() 方法用于获取计数器的当前值。

总结

在多线程编程中，synchronized 是一种常用的同步机制，它可以帮助我们实现多个线程之间的互斥访问，避免并发问题。在使用 synchronized 时，需要注意避免死锁问题和避免过多的同步代码块，以提高程序的性能和可靠性。同时，也可以使用其他的同步机制来替代 synchronized，如 Lock、ReadWriteLock 和 Atomic 类等。