public class SynchronizedExample {
    private int counter;
    public synchronized void increment() {
        counter++;
    }
    public synchronized int getCount() {
        return counter;
    }
}

public class SynchronizedStaticExample {
    private static int counter;
    public static synchronized void increment() {
        counter++;
    }
    public static synchronized int getCount() {
        return counter;
    }
}

public class SynchronizedBlockExample {
    private int counter;
    private Object lock = new Object();
    public void increment() {
        synchronized(lock) {
            counter++;
        }
    }
    public int getCount() {
        synchronized(lock) {
            return counter;
        }
    }
}

public class IntrinsicLockExample {
    private int counter = 0;
    // 同步實例方法，隱式使用 this 對象作為鎖
    public synchronized void increment() {
        counter++;
    }
    // 同步代碼塊，顯式指定鎖對象
    public void incrementWithBlock(Object lock) {
        synchronized (lock) {
            counter++;
        }
    }
    // 獲取當前計數(shù)
    public synchronized int getCount() {
        return counter;
    }
    // 示例類中的靜態(tài)變量和對應的同步方法
    private static int staticCounter = 0;
    public static synchronized void incrementStatic() {
        staticCounter++;
    }
}
// 使用示例
public class Main {
    public static void main(String[] args) {
        IntrinsicLockExample example = new IntrinsicLockExample();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final count: " + example.getCount());  // 輸出結果應為2000
        // 靜態(tài)成員的同步示例
        for (int i = 0; i < 500; i++) {
            IntrinsicLockExample.incrementStatic();
        }
        System.out.println("Final static count: " + IntrinsicLockExample.staticCounter);  // 輸出結果應為500
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class DisplayedLockExample {
    private final Lock lock = new ReentrantLock();
    private int counter;
    public void increment() {
        lock.lock(); // 加鎖
        try {
            counter++;
        } finally {
            lock.unlock(); // 無論何時都要確保解鎖
        }
    }
    public int getCount() {
        lock.lock(); // 同樣需要加鎖保護
        try {
            return counter;
        } finally {
            lock.unlock();
        }
    }
    // 顯示鎖還提供了更多的控制方式，比如嘗試獲取鎖，支持中斷等
    public void tryIncrementWithTimeout(int timeout, TimeUnit unit) throws InterruptedException {
        if (lock.tryLock(timeout, unit)) {
            try {
                counter++;
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println("未能在規(guī)定時間內(nèi)獲取到鎖");
        }
    }
}
// 使用示例
public class Main {
    public static void main(String[] args) {
        DisplayedLockExample example = new DisplayedLockExample();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final count: " + example.getCount());  // 輸出結果應為2000
    }
}

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockExample {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();
    private int sharedResource;
    public void read() {
        readLock.lock(); // 獲取讀鎖
        try {
            // 多個線程可以同時在這里讀取數(shù)據(jù)
            System.out.println("Reading the resource: " + sharedResource);
        } finally {
            readLock.unlock(); // 釋放讀鎖
        }
    }
    public void update() {
        writeLock.lock(); // 獲取寫鎖
        try {
            // 當有線程在執(zhí)行這里的寫操作時，其他所有讀寫線程都會被阻塞
            sharedResource++;
            System.out.println("Updated the resource to: " + sharedResource);
        } finally {
            writeLock.unlock(); // 釋放寫鎖
        }
    }
    // 使用示例
    public static void main(String[] args) {
        ReadWriteLockExample example = new ReadWriteLockExample();
        ExecutorService executor = Executors.newFixedThreadPool(10);
        // 創(chuàng)建大量讀取任務
        for (int i = 0; i < 20; i++) {
            executor.submit(() -> example.read());
        }
        // 創(chuàng)建少量寫入任務
        for (int i = 0; i < 5; i++) {
            executor.submit(() -> example.update());
        }
        // 關閉線程池
        executor.shutdown();
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionVariableExample {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    // 共享資源，模擬隊列為空的情況
    private boolean isEmpty = true;
    public void produce() {
        lock.lock();
        try {
            // 當隊列為空時，生產(chǎn)者線程等待condition被signal
            while (!isEmpty) {
                condition.await();  // 線程在此處釋放鎖并進入等待狀態(tài)
            }
            // 生產(chǎn)商品邏輯...
            System.out.println("Produced an item, queue is no longer empty.");
            isEmpty = false;  // 更新條件
            // 喚醒所有等待此condition的消費者線程
            condition.signalAll();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();  // 不論如何都要確保解鎖
        }
    }
    public void consume() {
        lock.lock();
        try {
            // 當隊列非空時，消費者線程等待condition被signal
            while (isEmpty) {
                condition.await();  // 線程在此處釋放鎖并進入等待狀態(tài)
            }
            // 消費商品邏輯...
            System.out.println("Consumed an item, queue is now empty.");
            isEmpty = true;  // 更新條件
            // 喚醒所有等待此condition的生產(chǎn)者線程
            condition.signalAll();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();  // 不論如何都要確保解鎖
        }
    }
    // 使用示例
    public static void main(String[] args) throws InterruptedException {
        ConditionVariableExample example = new ConditionVariableExample();
        Thread producer = new Thread(example::produce);
        Thread consumer = new Thread(example::consume);
        producer.start();
        consumer.start();
        // 確保生產(chǎn)者先啟動并改變條件
        Thread.sleep(100);
        example.produce();  // 手動調(diào)用一次生產(chǎn)方法，以初始化條件變化
        producer.join();
        consumer.join();
    }
}

import java.util.concurrent.atomic.AtomicInteger;
public class OptimisticLockingExample {
    private AtomicInteger counter = new AtomicInteger(0);
    public void increment() {
        // 讀取當前值
        int currentValue;
        do {
            // 獲取一個可能過時的值
            currentValue = counter.get();
            // 檢查在此期間是否已經(jīng)被其他線程修改過
        } while (!counter.compareAndSet(currentValue, currentValue + 1));  // 如果當前值未變，則更新為原值+1
        System.out.println("Counter incremented to: " + counter.get());
    }
    public static void main(String[] args) {
        OptimisticLockingExample example = new OptimisticLockingExample();
        Thread thread1 = new Thread(example::increment);
        Thread thread2 = new Thread(example::increment);
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class PessimisticLockingExampleJDBC {
    private static final String URL = "jdbc:mysql://localhost:3306/mydb";
    private static final String USER = "root";
    private static final String PASSWORD = "password";
    public void updateDataWithPessimisticLock(int id) {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD)) {
            connection.setAutoCommit(false); // 關閉自動提交，開始事務
            // 使用FOR UPDATE來獲取悲觀鎖
            String sql = "SELECT * FROM my_table WHERE id = ? FOR UPDATE";
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, id);
            preparedStatement.execute();
            // 假設我們從查詢結果中獲取了數(shù)據(jù)，并準備更新它...
            // 更新操作
            String updateSql = "UPDATE my_table SET column = ? WHERE id = ?";
            preparedStatement = connection.prepareStatement(updateSql);
            preparedStatement.setString(1, "new_value");
            preparedStatement.setInt(2, id);
            preparedStatement.executeUpdate();
            connection.commit();  // 提交事務，釋放鎖
        } catch (SQLException e) {
            // 處理異常并回滾事務
            try {
                if (connection != null) {
                    connection.rollback();
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }
    }
}

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class PessimisticLockingExampleHibernate {
    private SessionFactory sessionFactory;
    public PessimisticLockingExampleHibernate() {
        Configuration configuration = new Configuration().configure();
        sessionFactory = configuration.buildSessionFactory();
    }
    public void updateDataWithPessimisticLock(Integer id) {
        try (Session session = sessionFactory.openSession()) {
            // 開始事務
            session.beginTransaction();
            // 加載實體并顯式地請求悲觀鎖
            MyEntity entity = session.get(MyEntity.class, id, LockMode.PESSIMISTIC_WRITE);
            // 假設我們在這里修改了entity的屬性值...
            entity.setProperty("new_value");
            // 提交事務，同時釋放鎖
            session.getTransaction().commit();
        } catch (Exception e) {
            // 如果發(fā)生異常，則回滾事務
            if (session != null && session.getTransaction() != null && session.getTransaction().isActive()) {
                session.getTransaction().rollback();
            }
            e.printStackTrace();
        }
    }
}
@Entity
@Table(name = "my_table")
public class MyEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    // 其他屬性及getter、setter省略...
}

public class SpinLock {
    private volatile boolean isLocked = false;
    public void lock() {
        while (true) {
            if (!isLocked) { // 當鎖未被占用時
                if (compareAndSet(false, true)) { // 使用CAS操作嘗試獲取鎖
                    break; // 成功獲取鎖后退出自旋
                }
            }
            // 鎖被占用時，繼續(xù)循環(huán)（自旋）
        }
    }
    public void unlock() {
        isLocked = false; // 釋放鎖
    }
    // 使用AtomicBoolean或Unsafe等工具類提供的原子操作來實現(xiàn)compareAndSet
    private boolean compareAndSet(boolean expect, boolean update) {
        return java.util.concurrent.atomic.AtomicBoolean.compareAndSet(this.isLocked, expect, update);
    }
    // 示例用法
    public static void main(String[] args) {
        final SpinLock spinLock = new SpinLock();
        Thread t1 = new Thread(() -> {
            spinLock.lock();
            try {
                System.out.println("Thread 1 acquired the lock");
                Thread.sleep(1000); // 模擬執(zhí)行耗時任務
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                spinLock.unlock();
            }
        });
        Thread t2 = new Thread(() -> {
            spinLock.lock();
            try {
                System.out.println("Thread 2 acquired the lock");
            } finally {
                spinLock.unlock();
            }
        });
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.locks.StampedLock;
public class StampedLockExample {
    private final StampedLock lock = new StampedLock();
    // 共享資源
    private int sharedResource;
    public void read() {
        long stamp = lock.readLock(); // 獲取悲觀讀鎖
        try {
            // 在此塊中可以安全地讀取sharedResource
            System.out.println("Reading the resource: " + sharedResource);
        } finally {
            lock.unlockRead(stamp); // 釋放讀鎖
        }
    }
    public void optimisticRead() {
        long stamp = lock.tryOptimisticRead(); // 嘗試獲取樂觀讀鎖
        int localCopy = sharedResource;
        if (lock.validate(stamp)) { // 驗證在獲取戳記后，數(shù)據(jù)是否被其他線程修改過
            // 如果沒有被修改，則可以安全地使用localCopy
            System.out.println("Optimistically reading the resource: " + localCopy);
        } else {
            // 如果有被修改，需要升級到悲觀讀鎖或者重新讀取
            long newStamp = lock.readLock();
            try {
                // 現(xiàn)在可以安全地再次讀取資源
                localCopy = sharedResource;
                System.out.println("Upgraded to悲觀讀鎖, reading the resource: " + localCopy);
            } finally {
                lock.unlockRead(newStamp); // 釋放悲觀讀鎖
            }
        }
    }
    public void write(int newValue) {
        long stamp = lock.writeLock(); // 獲取寫鎖
        try {
            // 在此塊中可以安全地更新sharedResource
            sharedResource = newValue;
            System.out.println("Updated the resource to: " + sharedResource);
        } finally {
            lock.unlockWrite(stamp); // 釋放寫鎖
        }
    }
    // 使用示例
    public static void main(String[] args) {
        StampedLockExample example = new StampedLockExample();
        // 創(chuàng)建并啟動多個讀取者和寫入者線程...
    }
}