public class Test {
    public static void main(String[] args) {
        new Test().同步代码块();
        new Test().同步方法();
        Test.静态同步方法();
        Test.Lock锁();
    }

    // 可选择锁对象
    public void 同步代码块() {
        synchronized (this) {
            System.out.println("同步代码块，第一次获取锁");
            synchronized (this) {
                System.out.println("同步代码块，第二次获取锁");
            }
        }
    }

    // 对象锁，锁对象是this
    public synchronized void 同步方法() {
        System.out.println("同步方法，第一次获取锁");
        同步方法2();
    }

    public synchronized void 同步方法2() {
        System.out.println("同步方法，第二次获取锁");
    }


    // 类锁，锁对象是当前类的Class对象
    public static synchronized void 静态同步方法() {
        System.out.println("静态同步方法，第一次获取锁");
        静态同步方法2();
    }

    public static synchronized void 静态同步方法2() {
        System.out.println("静态同步方法，第二次获取锁");
    }

    // Lock锁
    public static void Lock锁() {
        Lock lock = new ReentrantLock();
        lock.lock();
        System.out.println("ReentrantLock，第一次获取锁");
        lock.lock();
        System.out.println("ReentrantLock，第二次获取锁");
        try {
            // ... 同步代码
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Lock lock = new UnReentrantLock();
        lock.lock();
        System.out.println("UnReentrantLock，第一次获取锁");
        lock.lock();
        System.out.println("UnReentrantLock，第二次获取锁");
        try {
            // ... 同步代码
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }
}

/**
 * 自定义一个不可重入锁
 */
class UnReentrantLock implements Lock {
    // 当前绑定的线程，记录以获取锁的线程
    private Thread bindThread;

    @Override
    public void lock() {
        synchronized (this) {
            // 当已有线程拿到锁时
            while (bindThread != null) {
                try {
                    // 使当前线程等待
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 绑定当前线程
            this.bindThread = Thread.currentThread();
        }
    }

    @Override
    public void unlock() {
        synchronized (this) {
            // 当绑定的线程不是当前线程时
            if (bindThread != Thread.currentThread()) {
                return;
            }
            // 解绑线程
            bindThread = null;
            // 唤醒所有线程，唤醒的线程可以继续绑定了
            notifyAll();
        }
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock() {
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {
    // 同步锁的结构和 ReentrantLock 完全相同
}

public class ReentrantLock implements Lock, java.io.Serializable {
    // 此锁的同步控制基础。下面分为公平和非公平版本。使用 AQS 状态来表示锁上的持有数量。
    abstract static class Sync extends AbstractQueuedSynchronizer {
    }
    // 公平锁的同步实现
    static final class FairSync extends Sync {
    }
    // 非公平锁的同步实现
    static final class NonfairSync extends Sync {
    }
}

public class Test {
    public static void main(String[] args) {
        Task task = new Task();
        Thread thread0 = new Thread(task);
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread0.start();
        thread1.start();
        thread2.start();
    }
}

class Task implements Runnable {
    @Override
    public void run() {
        while (true) {
            // 同步锁为this的同步代码块
            synchronized (this) {
                try {
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class Task implements Runnable {
    /**
     * 默认非公平锁
     */
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName());
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

public final boolean isFair() {
    return sync instanceof FairSync;
}

public class Test {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        System.out.println(lock.isFair()); // false
    }
}

public class Test {
    public static void main(String[] args) {
        Task task = new Task();
        Thread thread0 = new Thread(task);
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread0.start();
        thread1.start();
        thread2.start();
    }
}

class Task implements Runnable {
    /**
     * 读写锁
     */
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    /**
     * 读锁
     */
    private Lock readLock = this.readWriteLock.readLock();

    @Override
    public void run() {
        this.readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
    }
}

class Task implements Runnable {
    /**
     * 写锁
     */
    private Lock writeLock = this.readWriteLock.writeLock();
}

public class Test {
    public static void main(String[] args) {
        Thread threadA = new Thread(new LockA());
        Thread threadB = new Thread(new LockB());
        threadA.start();
        threadB.start();
    }
}

class LockA implements Runnable {
    @Override
    public void run() {
        printA();
    }

    public static synchronized void printA() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("A");
        // 持有类锁（LockA.class），争夺对方的锁（LockB.class）
        LockB.printB();
    }
}

class LockB implements Runnable {
    @Override
    public void run() {
        printB();
    }

    public static synchronized void printB() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("B");
        // 持有类锁（LockB.class），争夺对方的锁（LockA.class）
        LockA.printA();
    }
}

public class Test {
    public static void main(String[] args) {
        Account account = new Account("260731000", 100L);

        Draw yourself = new Draw(account, 50L, "Yourself");
        Draw girlFriend = new Draw(account, 31L, "GirlFriend");

        yourself.start();
        girlFriend.start();
    }
}

@Data
class Account {
    private String name;
    private long money;

    public Account(String name, long money) {
        this.name = name;
        this.money = money;
    }
}

class Draw extends Thread {
    private Account account;

    private long drawMoney; // 取款金额

    public Draw(Account account, long drawMoney, String threadName) {
        super(threadName);
        this.account = account;
        this.drawMoney = drawMoney;
    }

    @Override
    public void run() {
        // synchronized(被锁对象)：锁的对象就是数据修改的对象
        synchronized (account) {
            if (account.getMoney() - drawMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "余额不足");
                return;
            }

            // sleep模拟取钱过程
            try {
                TimeUnit.SECONDS.sleep(1L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.printf("%s 账户余额: %d \t 取款金额: %d \t 剩余金额: %d \t 取款人: %s \n",
                    account.getName(),
                    account.getMoney(),
                    drawMoney,
                    account.getMoney() - drawMoney,
                    this.getName());

            account.setMoney(account.getMoney() - drawMoney);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Account account = new Account("260731000", 100L);

        Draw yourselfDraw = new Draw(account, 50L);
        Thread yourself = new Thread(yourselfDraw, "Yourself");

        Draw girlFriendDraw = new Draw(account, 31L);
        Thread girlFriend = new Thread(girlFriendDraw, "GirlFriend");

        yourself.start();
        girlFriend.start();
    }
}

@Data
class Account {
    private String name;
    private long money;

    public Account(String name, long money) {
        this.name = name;
        this.money = money;
    }
}

class Draw implements Runnable {
    private Account account;

    private long drawMoney; // 取款金额

    public Draw(Account account, long drawMoney) {
        this.account = account;
        this.drawMoney = drawMoney;
    }

    @Override
    public void run() {
        // synchronized(被锁对象)：锁的对象就是数据修改的对象
        synchronized (account) {
            if (account.getMoney() - drawMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "余额不足");
                return;
            }

            // sleep模拟取钱过程
            try {
                TimeUnit.SECONDS.sleep(1L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.printf("%s 账户余额: %d \t 取款金额: %d \t 剩余金额: %d \t 取款人: %s \n",
                    account.getName(),
                    account.getMoney(),
                    drawMoney,
                    account.getMoney() - drawMoney,
                    Thread.currentThread().getName());

            account.setMoney(account.getMoney() - drawMoney);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Account account = new Account("260731000", 100L);

        Draw yourselfDraw = new Draw(account, 50L);
        Thread yourself = new Thread(yourselfDraw, "Yourself");

        Draw girlFriendDraw = new Draw(account, 31L);
        Thread girlFriend = new Thread(girlFriendDraw, "GirlFriend");

        yourself.start();
        girlFriend.start();
    }
}

@Data
class Account {
    private String name;
    private long money;
    private final ReentrantLock lock = new ReentrantLock(true);

    public Account(String name, long money) {
        this.name = name;
        this.money = money;
    }
}

class Draw implements Runnable {
    private Account account;

    private long drawMoney; // 取款金额

    public Draw(Account account, long drawMoney) {
        this.account = account;
        this.drawMoney = drawMoney;
    }

    @Override
    public void run() {
        // synchronized(被锁对象)：锁的对象就是数据修改的对象
        try {
            account.getLock().lockInterruptibly();
            if (account.getMoney() - drawMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "余额不足");
                return;
            }

            // sleep模拟取钱过程
            try {
                TimeUnit.SECONDS.sleep(1L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.printf("%s 账户余额: %d \t 取款金额: %d \t 剩余金额: %d \t 取款人: %s \n",
                    account.getName(),
                    account.getMoney(),
                    drawMoney,
                    account.getMoney() - drawMoney,
                    Thread.currentThread().getName());

            account.setMoney(account.getMoney() - drawMoney);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            account.getLock().unlock();
            account.getLock().unlock(); // 抛出： IllegalMonitorStateException – 如果当前线程没有持有这个锁
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        // Vector是线程安全的时候才去考虑使用的，但即使要安全，也不用
        List<String> list1 = new ArrayList<String>();// 线程不安全
        List<String> list2 = Collections.synchronizedList(list1); // 线程安全
    }
}

public class Test {
    public static volatile int i = 0;

    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                int expectedValue = i;
                System.out.println("期望值: " + expectedValue);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // CAS操作
                boolean result = compareAndSwap(i, expectedValue, i + 1);
                System.out.println("设置是否成功: " + result);
                System.out.println("新值: " + i);
            }
        };
        thread.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        i = 5;
    }

    public static boolean compareAndSwap(int memoryValue, int expectedValue, int newValue) {
        // 当预期原值等于内存值时
        if (expectedValue == memoryValue) {
            i = memoryValue;
            return true;
        }
        return false;
    }
}

public interface Lock {
    // 这四个方法都可以获取锁
    void lock();
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void lockInterruptibly() throws InterruptedException;
    
    // 释放锁
    void unlock();
    
    // 用于等待通知（线程间通信）
    Condition newCondition();
}

private final Lock lock = new XxxLock();

public void doSomething() {
    lock.lock(); // 获取锁，阻塞
    try {
        // ... 同步代码
    } catch (Exception e) {

    } finally {
        lock.unlock(); // 释放锁
    }
}

public class Test {
    public static void main(String[] args) {
        Task task = new Task();
        Thread thread0 = new Thread(task);
        Thread thread1 = new Thread(task);
        thread0.start();
        thread1.start();
    }
}

class Task implements Runnable {
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        lock.lock(); // 获取锁，阻塞
        try {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

class SellTicket implements Runnable {
    // 定义票
    private int tickets = 1;
    // 定义锁对象
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            lock.lock(); // 获取锁，阻塞
            try {
                if (tickets <= 100) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets++) + "张票");
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();// 释放锁
            }
        }
    }
}

private final Lock lock = new XxxLock();

public void doSomething() {
    if (lock.tryLock()) { // 获取锁，非阻塞
         try {
             // ... 同步代码
         } catch (Exception e) {

         } finally {
             lock.unlock(); // 释放锁
         } 
    } else {
        System.out.println("锁被占用，执行其他任务。");
    }
}

private final Lock lock = new XxxLock();

public void doSomething() throws InterruptedException {
    try {
        if (lock.tryLock(1000, TimeUnit.SECONDS)) { // 定时获取锁，定时阻塞，可中断
            try {
                // ... 同步代码
            } catch (Exception e) {

            } finally {
                lock.unlock(); // 释放锁
            }
        } else {
            System.out.println("锁被占用，执行其他任务。");
        }
    } catch (InterruptedException e) {
        System.out.println(Thread.currentThread().getName() + " 获取锁时被中断");
    }
}

public class Test {
    public static void main(String[] args) {
        Task task = new Task();
        Thread thread0 = new Thread(task);
        Thread thread1 = new Thread(task);
        thread0.start();
        thread1.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 中断线程
        thread1.interrupt();
    }
}

class Task implements Runnable {
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            if (lock.tryLock(1000, TimeUnit.SECONDS)) { // 定时获取锁，定时阻塞，可中断
                try {
                    Thread.sleep(3000);
                    System.out.println(Thread.currentThread().getName() + " 执行完成");
                } catch (InterruptedException e) {
                    System.out.println(Thread.currentThread().getName() + " sleep时被中断");
                } finally {
                    lock.unlock(); // 释放锁
                }
            } else {
                System.out.println("锁被占用，执行其他任务。");
            }
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + " 获取锁时被中断");
        }
    }
}

private final Lock lock = new XxxLock();

public void doSomething() {
    try {
        lock.lockInterruptibly(); // 获取锁，阻塞，可中断
    } catch (InterruptedException e) {
        System.out.println(Thread.currentThread().getName() + " 获取锁时被中断");
        return;
    }
    
    try {
        // ... 同步代码
    } catch (Exception e) {

    } finally {
        lock.unlock(); // 释放锁
    }
}

public class Test {
    public static void main(String[] args) {
        Task task = new Task();
        Thread thread0 = new Thread(task);
        Thread thread1 = new Thread(task);
        thread0.start();
        thread1.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 中断线程
        thread1.interrupt();
    }
}

class Task implements Runnable {
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            lock.lockInterruptibly(); // 获取锁，阻塞，可中断
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + " 获取锁时被中断");
            return;
        }

        try {
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " 执行完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

public final boolean isFair() // 判断锁是否是公平锁
public boolean isLocked() // 查询此锁是否被任何线程持有。此方法设计用于监视系统状态，而不是用于同步控制。
public boolean isHeldByCurrentThread() // 查询当前线程是否持有此锁。
public final boolean hasQueuedThreads() // 查询是否有线程正在等待获取此锁。请注意，取消可能随时发生，如果可能有其他线程等待获取锁，则返回true。该方法主要设计用于监视系统状态。

public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}

public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {
    /** Inner class providing readlock */
    private final ReentrantReadWriteLock.ReadLock readerLock;
    /** Inner class providing writelock */
    private final ReentrantReadWriteLock.WriteLock writerLock;
    
    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }
    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
    
    public static class ReadLock implements Lock, java.io.Serializable {
        // ...
    }
    public static class WriteLock implements Lock, java.io.Serializable {
        // ...
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建高并发容器
        ReadWriteDictionary dictionary = new ReadWriteDictionary();
        // 创建读、写任务
        WriteTask writeTask = new WriteTask(dictionary);
        ReadTask readTask = new ReadTask(dictionary);
        // 创建读、写线程
        Thread writeThread0 = new Thread(writeTask);
        Thread writeThread1 = new Thread(writeTask);
        Thread writeThread2 = new Thread(writeTask);
        Thread readThread3 = new Thread(readTask);
        Thread readThread4 = new Thread(readTask);
        Thread readThread5 = new Thread(readTask);
        // 启动线程
        writeThread0.start();
        writeThread1.start();
        writeThread2.start();
        readThread3.start();
        readThread4.start();
        readThread5.start();
    }
}

/**
 * 从容器读取数据的任务
 */
class ReadTask implements Runnable {
    private ReadWriteDictionary dictionary;

    public ReadTask(ReadWriteDictionary dictionary) {
        this.dictionary = dictionary;
    }

    @Override
    public void run() {
        // 无限读取
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 获取所有key
            String[] keys = dictionary.allKeys();
            // 遍历所有的key
            for (String key : keys) {
                Object value = dictionary.get(key);
                String threadName = Thread.currentThread().getName();
                System.out.println(threadName + "读取 >>> " + key + ": " + value);
            }
        }
    }
}

/**
 * 向容器写入数据的任务
 */
class WriteTask implements Runnable {
    private ReadWriteDictionary dictionary;

    public WriteTask(ReadWriteDictionary dictionary) {
        this.dictionary = dictionary;
    }

    @Override
    public void run() {
        // 计数器
        int i = 0;
        // 无限写入
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object value = Thread.currentThread().getName() + "写入" + i++;
            // 存储数据
            dictionary.put("固定key", value);
        }
    }
}

/**
 * 高并发容器
 */
class ReadWriteDictionary {
    /**
     * key-value容器
     */
    private final Map<String, Object> map = new HashMap<>();

    /**
     * 读写锁
     */
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);

    /**
     * 读锁
     */
    private final Lock readLock = readWriteLock.readLock();

    /**
     * 写锁
     */
    private final Lock writeLock = readWriteLock.writeLock();

    public Object get(String key) {
        readLock.lock();
        try {
            return map.get(key);
        } finally {
            readLock.unlock();
        }
    }

    /**
     * 返回所有键
     */
    public String[] allKeys() {
        readLock.lock();
        try {
            return map.keySet().toArray(new String[0]);
        } finally {
            readLock.unlock();
        }
    }

    public Object put(String key, Object value) {
        writeLock.lock();
        try {
            return map.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }

    public void clear() {
        writeLock.lock();
        try {
            map.clear();
        } finally {
            writeLock.unlock();
        }
    }
}

public class Test {
    public static final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    public static final Lock readLock = readWriteLock.readLock();
    public static final Lock writeLock = readWriteLock.writeLock();

    public static void main(String[] args) {
        printA();
    }

    private static void printA() {
        readLock.lock();
        try {
            System.out.println("printA");
            printB();
        } finally {
            readLock.unlock();
        }
    }

    private static void printB() {
        writeLock.lock();
        try {
            System.out.println("printB");
        } finally {
            writeLock.unlock();
        }
    }
}

public class LockSupport {
    private LockSupport() {} // 无法实例化
    
    /*********** 无限等待 ************/
    // 使当前线程等待，直到唤醒或中断
    public static void park();
    // 使当前线程等待，并指定同步锁，直到唤醒或中断
    public static void park(Object blocker);
    
    /*********** 定时等待***********/
    // 使当前线程等待，并指定等待时间，直到唤醒或中断或超时
    public static void parkNanos(long nanos);
    // 使当前线程等待，并指定同步锁和等待时间，直到唤醒或中断或超时
    public static void parkNanos(Object blocker, long nanos);
    // 使当前线程等待，并指定截止日期，直到唤醒或超时
    public static void parkUntil(long deadline);
    // 使当前线程等待，并指定同步锁和截止日期，直到唤醒或中断或超时
    public static void parkUntil(Object blocker, long deadline);
    
    // 唤醒指定线程
    public static void unpark(Thread thread);
    
    // 获取指定线程的同步锁
    public static Object getBlocker(Thread t);
}

public class Test {
    public static void main(String[] args) {
        Task task = new Task();
        Thread thread = new Thread(task);
        thread.start();

        try {
            thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        LockSupport.unpark(thread);
    }
}


/**
 * 从容器读取数据的任务
 */
class Task implements Runnable {
    @Override
    public void run() {
        System.out.println("等待前");
        LockSupport.park();
        System.out.println("等待后");
    }
}

public class Test {
    public static void main(String[] args) {
        Data data = new Data();
        ReadTask readTask = new ReadTask(data);
        WriteTask writeTask = new WriteTask(data);
        Thread thread0 = new Thread(readTask);
        Thread thread1 = new Thread(writeTask);
        thread0.start();
        thread1.start();
    }
}

class ReadTask implements Runnable {
    private Data data;

    public ReadTask(Data data) {
        this.data = data;
    }

    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println(data.getMessage());
        }
    }
}

class WriteTask implements Runnable {
    private Data data;

    public WriteTask(Data data) {
        this.data = data;
    }

    @Override
    public void run() {
        // 计数器
        int i = 0;
        while (!Thread.currentThread().isInterrupted()) {
            data.setMessage("当前值: " + i++);
        }
    }
}

class Data {
    private String message;
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final Lock readLock = readWriteLock.readLock();
    private final Lock writeLock = readWriteLock.writeLock();

    public String getMessage() {
        readLock.lock();
        try {
            Thread.sleep(1000);
            return this.message;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return null;
        } finally {
            readLock.unlock();
        }
    }

    public void setMessage(String message) {
        writeLock.lock();
        try {
            Thread.sleep(1000);
            this.message = message;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock();
        }
    }
}

class Data {
    private String message;
    private final StampedLock stampedLock = new StampedLock();

    public String getMessage() {
        // 获取读锁标识
        long readStamp = stampedLock.readLock();
        try {
            Thread.sleep(1000);
            return this.message;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return null;
        } finally {
            // 释放读锁
            stampedLock.unlockRead(readStamp);
        }
    }

    public void setMessage(String message) {
        // 获取写锁标识
        long writeStamp = stampedLock.writeLock();
        try {
            Thread.sleep(1000);
            this.message = message;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放写锁
            stampedLock.unlockWrite(writeStamp);
        }
    }
}

public class Test {
    public static StampedLock stampedLock = new StampedLock();

    public static void main(String[] args) {
        printA();
    }

    private static void printA() {
        long stamp = stampedLock.readLock();
        try {
            System.out.println("printA");
            printB();
        } finally {
            stampedLock.unlockRead(stamp);
        }
    }

    private static void printB() {
        long stamp = stampedLock.writeLock();
        try {
            System.out.println("printB");
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }
}

/**
 * JVM参数：-Xms30m -Xmx30m
 */
public class Test {
    public static ThreadLocal<Object> threadLocal = new ThreadLocal<>();
    // 执行次数
    public static AtomicInteger cnt = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        // 这里休眠10s，待visualVM连接后继续
        TimeUnit.SECONDS.sleep(10);

        ExecutorService executorService =
                new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS, new SynchronousQueue<>(), new DiscardPolicy());
        for (int i = 1000; i > 0; i--) {
            executorService.submit(new Task());
            TimeUnit.MILLISECONDS.sleep(10);
        }

        executorService.shutdown();
    }
}

class Task implements Runnable {
    private int _1MB = 1024 * 1024 * 1;

    @Override
    public void run() {
        Byte[] byt = new Byte[_1MB];
        Test.threadLocal.set(byt);
        System.out.println(Test.cnt.incrementAndGet());
        // Test.threadLocal.remove();
    }
}