基于Java回顾之多线程同步的使用详解

简介

多线程编程是Java开发中的重要理念，但同时也需要考虑到线程安全问题。本篇文章主要介绍如何使用Java多线程同步技术保证线程安全。

同步机制

Java提供了两种主要的同步机制：synchronized和Lock。

synchronized

synchronized是Java中最主要的同步机制，可以用来确保多线程访问共享数据时的安全。synchronized有两种使用方式：同步方法和同步块。

同步方法

在Java中，每个对象都有锁，synchronized关键词可以将对象锁住，为了同步一个方法，需要使用synchronized关键词标记方法。例如：

public synchronized void synchronizedMethod(){
    // ...
}

同步块

同步块是一个代码片段，它们用关键字synchronized标记，并且需要提供锁定对象。例如：

public void syncBlock(Object obj){
    synchronized(obj){
        // ...
    }
}

Lock

Lock旨在提供比synchronized更大的灵活性和更精细的控制，它提供了tryLock()和tryLock(long timeout, TimeUnit unit)方法，可以更好地适应特定的需求。

示例

示例一

public class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

以上示例中，使用Lock实现了线程安全的计数器。increment()方法使用了Lock.lock()方法获取锁，防止多线程并发执行。count++语句可以视作一个“临界区”，需要保证同步执行，最后使用Lock.unlock()方法释放锁。

示例二

public class Buffer {
    private char[] buffer;
    private int readPos;
    private int writePos;

    public Buffer(int size) {
        buffer = new char[size];
    }

    public synchronized void write(char c) {
        while (availableSpace() == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        buffer[writePos] = c;
        writePos = (writePos + 1) % buffer.length;
        notifyAll();
    }

    public synchronized char read() {
        while (availableData() == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        char c = buffer[readPos];
        readPos = (readPos + 1) % buffer.length;
        notifyAll();
        return c;
    }

    private int availableSpace() {
        return buffer.length - availableData();
    }

    private int availableData() {
        return (writePos - readPos + buffer.length) % buffer.length;
    }
}

以上示例中，使用了synchronized和wait/notifyAll方法实现了一个生产者-消费者模型，生产者不断写入数据到缓冲区，消费者不断从缓冲区读取数据，当缓冲区已满时，生产者需要等待；当缓冲区已空时，消费者需要等待。在wait、notifyAll等地方使用synchronized实现同步，以防止线程并发问题。

结论

Java提供了多种多线程同步机制，如synchronized和Lock，需要根据具体需求选择不同的机制。在实现多线程同步时，需要考虑到线程安全问题，避免因多线程并发而引发的不确定行为。