Java中锁的全面解析之类型、使用场景、优缺点及实现方式(示例代码)

public class counter {
    private int count = 0;
    // 同步方法，使用对象锁（this）
    public synchronized void increment() {
        count++;
    }
    // 同步代码块，使用指定对象锁
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }
    public int getcount() {
        return count;
    }
}

import java.util.concurrent.locks.reentrantlock;
public class reentrantexample {
    private final reentrantlock lock = new reentrantlock();
    private int count = 0;
    public void increment() {
        lock.lock();
        try {
            count++;
            // 可以再次获取锁（可重入）
            if (count == 1) {
                system.out.println("thread " + thread.currentthread().getname() + " is re-entering the lock.");
            }
        } finally {
            lock.unlock();
        }
    }
    public int getcount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

import java.util.concurrent.locks.readwritelock;
import java.util.concurrent.locks.reentrantreadwritelock;
public class readwriteexample {
    private final readwritelock lock = new reentrantreadwritelock();
    private string data = "default";
    // 读操作：多个线程可同时读
    public string readdata() {
        lock.readlock().lock();
        try {
            system.out.println(thread.currentthread().getname() + " is reading data: " + data);
            return data;
        } finally {
            lock.readlock().unlock();
        }
    }
    // 写操作：独占访问，其他读写均被阻塞
    public void writedata(string newdata) {
        lock.writelock().lock();
        try {
            system.out.println(thread.currentthread().getname() + " is writing data: " + newdata);
            data = newdata;
        } finally {
            lock.writelock().unlock();
        }
    }
}

import java.util.concurrent.atomic.atomicinteger;
public class atomiccounter {
    private final atomicinteger count = new atomicinteger(0);
    public void increment() {
        count.incrementandget(); // cas 操作，原子递增
    }
    public int getcount() {
        return count.get();
    }
}

import java.util.concurrent.locks.stampedlock;
public class stampedlockexample {
    private final stampedlock stampedlock = new stampedlock();
    private double x, y;
    // 乐观读：不加锁，先尝试读取，失败则升级为悲观读
    public double distancefromorigin() {
        long stamp = stampedlock.tryoptimisticread();
        double currentx = x, currenty = y;
        // 检查是否在读期间发生了写操作（版本变化）
        if (!stampedlock.validate(stamp)) {
            stamp = stampedlock.readlock();
            try {
                currentx = x;
                currenty = y;
            } finally {
                stampedlock.unlockread(stamp);
            }
        }
        return math.sqrt(currentx * currentx + currenty * currenty);
    }
    // 写操作：独占锁
    public void move(double deltax, double deltay) {
        long stamp = stampedlock.writelock();
        try {
            x += deltax;
            y += deltay;
        } finally {
            stampedlock.unlockwrite(stamp);
        }
    }
}