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();
    }
}

public class Test {
    public static final ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();

    public static void main(String[] args) {
        threadLocal.set("Hello World!");
        new ThreadB().start();
    }
}

class ThreadB extends Thread {
    @Override
    public void run() {
        System.out.println(Test.threadLocal.get());
    }
}

public class Test {
    private static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            System.out.println("ThreadA开始执行...");
            while (flag) { // 等同于 while (true)
                // Thread.yield(); // 其实这里sleep或yield一下就不需要用volatile修饰了
                if (!flag) {
                    System.out.println("跳出循环");
                    break;
                }
            }
            System.out.println("ThreadA结束执行。。。");
        }, "ThreadA").start();

        TimeUnit.SECONDS.sleep(1);
        flag = false;
        System.out.println("标识已经变更");
    }
}

public class Test {
    private static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            System.out.println("ThreadA开始执行...");
            while (flag) {
                System.out.println("跳出循环");
            }
            System.out.println("ThreadA结束执行。。。");
        }, "ThreadA").start();

        TimeUnit.SECONDS.sleep(1);
        flag = false;
        System.out.println("标识已经变更");
    }
}

public class Test {
    private static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            System.out.println("ThreadA开始执行...");
            int i = 0;
            while (flag) {
                i++;
            }
            System.out.println("ThreadA结束执行。。。");
        }, "ThreadA").start();

        TimeUnit.SECONDS.sleep(1);
        flag = false;
        System.out.println("标识已经变更");
    }
}

public class Test {
    // volatile不保证原子性
    // 原子性：保证数据一致性、完整性
    private static volatile int num = 0;

    public static void main(String[] args) throws InterruptedException {
        for (int j = 0; j < 2; j++) {
            new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    Test.num++;
                }
            }, String.valueOf(j)).start();
        }

        // 后台默认两个线程：一个是main线程，一个是gc线程
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "final num result = " + Test.num);
        Thread.sleep(5000); // 由于不了解Thread.activeCount()，担心还有线程未执行完，所以休眠后再输出一次，事实证明Thread.activeCount()可靠
        // 如果volatile保证原子性的话，最终的结果应该是20000。但是每次程序执行结果都不等于20000。
        System.out.println(Thread.currentThread().getName() + "final num result = " + Test.num);
    }
}

synchronized(对象) { // 对象锁
	// 需要被同步的代码;
}

synchronized(this) { // 对象锁
	// 需要被同步的代码;
}

synchronized(类.class) { // 类锁
	// 需要被同步的代码;
}

public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket st = new SellTicket();

        // 创建三个线程对象
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

class SellTicket extends Stock implements Runnable {

    /**
     * 创建锁对象
     */
    private Object objLock = new Object();

    @Override
    public void run() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // 已售票数小于库存，就进行售票
        while (sellTickets < originalStock) {
            // synchronized (new Object()) 不同锁对象
	    // synchronized (this) 对象锁
	    // synchronized (Object.class) 类锁
            synchronized (objLock) {
                if (sellTickets < originalStock) {
                    try {
                        // 模拟售票员正在售票
                        Thread.sleep(100);
                        // 注意这里通过 Thread.currentThread().getName() 获取线程名
                        System.out.println(Thread.currentThread().getName() + "\t\t正在出售第" + (++sellTickets) + "张票\t\t" +
                                "原始库存" + originalStock + "张票\t\t");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } 
                }
            }
        }
        stopWatch.stop();
        System.out.println(Thread.currentThread().getName() + "总耗时: " + stopWatch.getTotalTimeNanos());
    }
}

public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket st = new SellTicket();

        // 创建三个线程对象
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

class SellTicket extends Stock implements Runnable {

    @Override
    public void run() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // 已售票数小于库存，就进行售票
        while (sellTickets < originalStock) {
            sell();
        }
        stopWatch.stop();
        System.out.println(Thread.currentThread().getName() + "总耗时: " + stopWatch.getTotalTimeNanos());
    }

    // 下面两个sell方法的锁对象相同
    private synchronized void sell() {
        if (sellTickets < originalStock) {
            try {
                // 模拟售票员正在售票
                Thread.sleep(100);
                // 注意这里通过 Thread.currentThread().getName() 获取线程名
                System.out.println(Thread.currentThread().getName() + "\t\t正在出售第" + (++sellTickets) + "张票\t\t" +
                        "原始库存" + originalStock + "张票\t\t");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    private void sell() {
        synchronized (this) {
            if (sellTickets < originalStock) {
                try {
                    // 模拟售票员正在售票
                    Thread.sleep(100);
                    // 注意这里通过 Thread.currentThread().getName() 获取线程名
                    System.out.println(Thread.currentThread().getName() + "\t\t正在出售第" + (++sellTickets) + "张票\t" +
                            "\t" +
                            "原始库存" + originalStock + "张票\t\t");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket st1 = new SellTicket();
	SellTicket st2 = new SellTicket();
	SellTicket st3 = new SellTicket();

        // 创建三个线程对象
        Thread t1 = new Thread(st1, "窗口1");
        Thread t2 = new Thread(st2, "窗口2");
        Thread t3 = new Thread(st3, "窗口3");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

class SellTicket extends Stock implements Runnable {

    @Override
    public void run() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // 已售票数小于库存，就进行售票
        while (sellTickets < originalStock) {
            sell();
        }
        stopWatch.stop();
        System.out.println(Thread.currentThread().getName() + "总耗时: " + stopWatch.getTotalTimeNanos());
    }

    // 类锁
    private static synchronized void sell() {
        if (sellTickets < originalStock) {
            try {
                // 模拟售票员正在售票
                Thread.sleep(100);
                // 注意这里通过 Thread.currentThread().getName() 获取线程名
                System.out.println(Thread.currentThread().getName() + "\t\t正在出售第" + (++sellTickets) + "张票\t\t" +
                        "原始库存" + originalStock + "张票\t\t");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    // 类锁
    private void sell() {
        synchronized (this.getClass()) {
            if (sellTickets < originalStock) {
                try {
                    // 模拟售票员正在售票
                    Thread.sleep(100);
                    // 注意这里通过 Thread.currentThread().getName() 获取线程名
                    System.out.println(Thread.currentThread().getName() + "\t\t正在出售第" + (++sellTickets) + "张票\t" +
                            "\t" +
                            "原始库存" + originalStock + "张票\t\t");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class Singleton {
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
    if (singleton == null) {
        synchronized (Singleton.class) {
            if (singleton == null) {
                singleton = new Singleton(); // 1
            }
        }
    }
    return singleton; // 2
    }
}
// Double-Check的目的是延迟初始化单例的一种方法
// 使用volatile关键字的主要目的是防止指令重排序。如果volatile不加入，jvm可以对指令进行重排，与类锁无关，过程1可能被拿到过程2进行延迟初始化，这样就违背了Double-Check目的与原则。
// 第一层if判断是为了减少多次synchronized，减少每次都同步，提升性能
// 第二层if为了防止同时锁后，进行多个实例创建

public class Test {
    public static boolean stopped = false;
    //public static volatile boolean stopped = false; // volatile关键字保证可见性

    public static void main(String[] args) {
        new Thread(() -> {
            // 当stopped为true时停止循环
            while (!stopped) {
                //Thread.sleep(0); // 也可以获取到stopped状态的改变
            }
        }).start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 停止循环
        stopped = true;
    }
}

　　public File(String pathname)：通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
　　public File(String parent, String child)：根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
　　public File(File parent, String child)：根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

public class FileDemo {
    public static void main(String[] args) {
        // File(String pathname)：根据一个路径得到File对象
        // 把e:\\demo\\a.txt封装成一个File对象
        File file = new File("G:\\demo\\a.txt");
        System.out.println(file);// G:\demo\a.txt

        // File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
        File file2 = new File("G:\\demo", "a.txt");
        System.out.println(file2);// G:\demo\a.txt

        // File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
        File file3 = new File("G:\\demo");
        File file4 = new File(file3, "a.txt");
        System.out.println(file4);// G:\demo\a.txt

        // 以上三种方式其实效果一样
    }
}

　　A:创建功能：
　　　　public boolean createNewFile() throws IOException
　　　　public boolean mkdir()
　　　　public boolean mkdirs()

　　B:删除功能：
　　　　public boolean delete()：删除此抽象路径名表示的文件或目录。

　　C:重命名功能
　　　　public boolean renameTo(File dest)

　　D:判断功能
　　　　public boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。
　　　　public boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
　　　　public boolean exists()：测试此抽象路径名表示的文件或目录是否存在。
　　　　public boolean canRead()：测试应用程序是否可以读取此抽象路径名表示的文件。 是否可读
　　　　public boolean canWrite()：测试应用程序是否可以修改此抽象路径名表示的文件。 是否可写
　　　　public boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。

　　E:获取功能
　　　　public File getAbsoluteFile()：返回此抽象路径名的绝对路径名形式。
　　　　public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
　　　　public String getPath()：将此抽象路径名转换为一个路径名字符串。获取相对路径。
　　　　public String getName()：返回由此抽象路径名表示的文件或目录的名称。
　　　　public long length()：返回由此抽象路径名表示的文件的长度（字节数）。如果此路径名表示一个目录，则返回值是不确定的。
　　　　public long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间（毫秒值）。

　　F:高级获取功能
　　　　public String[] list()：返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。 获取指定目录下的所有文件或者文件夹的名称数组
　　　　public File[] listFiles()：返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。 获取指定目录下的所有文件或者文件夹的File数组

　　G:过滤器功能
　　　　public String[] list(FilenameFilter filter)：返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
　　　　public File[] listFiles(FilenameFilter filter)：返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
　　　　public File[] listFiles(FileFilter filter)：返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

/*
 * 创建功能：
 */
public class FileDemo {
    public static void main(String[] args) throws IOException {
        // 需求：我要在G盘目录下创建一个文件夹demo
        File file = new File("G:\\demo");
        System.out.println("mkdir:" + file.mkdir());

        // 需求:我要在G盘目录demo下创建一个文件a.txt
        File file2 = new File("G:\\demo\\a.txt");
        System.out.println("createNewFile:" + file2.createNewFile());

        // 需求：我要在G盘目录test下创建一个文件b.txt
        // Exception in thread "main" java.io.IOException: 系统找不到指定的路径。
        // 注意：要想在某个目录下创建内容，该目录首先必须存在。
        // File file3 = new File("G:\\test\\b.txt");
        // System.out.println("createNewFile:" + file3.createNewFile());

        // 需求:我要在G盘目录test下创建aaa目录
        // File file4 = new File("G:\\test\\aaa");
        // System.out.println("mkdir:" + file4.mkdir());

        // File file5 = new File("G:\\test");
        // File file6 = new File("G:\\test\\aaa");
        // System.out.println("mkdir:" + file5.mkdir());
        // System.out.println("mkdir:" + file6.mkdir());

        // 其实我们有更简单的方法
        // File file7 = new File("G:\\aaa\\bbb\\ccc\\ddd");
        // System.out.println("mkdirs:" + file7.mkdirs());

        // 看下面的这个东西：
        // File file8 = new File("G:\\liuyi\\a.txt\\aaa");
        // System.out.println("mkdirs:" + file8.mkdirs());// 只能创建文件夹
    }
}

/*
 * 删除功能:public boolean delete()
 * 
 * 注意：
 *         A:如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下。
 *         B:Java中的删除不走回收站。
 *         C:如果此路径名表示一个目录(文件夹)，则该目录必须为空才能删除。 
 */
public class FileDemo {
    public static void main(String[] args) throws IOException {
        // 创建文件
        // File file = new File("e:\\a.txt");
        // System.out.println("createNewFile:" + file.createNewFile());

        // 不写盘符路径时，默认在项目路径下
        File file = new File("a.txt");
        System.out.println("createNewFile:" + file.createNewFile());
        System.out.println("delete:" + file.delete());

        File file2 = new File("aaa\\bbb\\ccc");
        System.out.println("mkdirs:" + file2.mkdirs());

        // 删除功能：我要删除aaa文件夹，必须先删ccc文件夹，再删bbb文件夹，最后才能删除aaa文件夹
        // File file4 = new File("aaa\\bbb\\ccc");
        // File file6 = new File("aaa\\bbb");
        File file7 = new File("aaa");
        // System.out.println("delete:" + file4.delete());
        // System.out.println("delete:" + file6.delete());
        System.out.println("delete:" + file7.delete());
    }
}

/*
 * 重命名功能:public boolean renameTo(File dest)
 *         如果路径名相同，就是改名。
 *         如果路径名不同，就是改名并剪切。
 * 
 * 路径以盘符开始：绝对路径    c:\\a.txt
 * 路径不以盘符开始：相对路径    a.txt
 */
public class FileDemo {
    public static void main(String[] args) throws IOException {
        // 创建一个文件对象
        // File file = new File("林青霞.jpg");
        // System.out.println(file.createNewFile());
        // 需求：我要修改这个文件的名称为"东方不败.jpg"
        // File newFile = new File("东方不败.jpg");
        // System.out.println("renameTo:" + file.renameTo(newFile));

        File file2 = new File("东方不败.jpg");
        File newFile2 = new File("G:\\林青霞.jpg");
        System.out.println("renameTo:" + file2.renameTo(newFile2));
    }
}

/*
 * 判断功能：
 */
public class FileDemo {
    public static void main(String[] args) throws IOException {
        // 创建文件对象
        File file = new File("a.txt");
        System.out.println(file.createNewFile());

        System.out.println("isDirectory:" + file.isDirectory());// false
        System.out.println("isFile:" + file.isFile());// true
        System.out.println("exists:" + file.exists());// true
        System.out.println("canRead:" + file.canRead());// true
        System.out.println("canWrite:" + file.canWrite());// true
        System.out.println("isHidden:" + file.isHidden());// false
    }
}

/*
 * 获取功能：
 */
public class FileDemo {
    public static void main(String[] args) throws IOException {
        // 创建文件对象
        File file = new File("test.txt");
        file.createNewFile();

        System.out.println("getAbsolutePath:" + file.getAbsolutePath()); // E:\WorkspacesOxygen\DemosSpace\JavaProject\test.txt
        System.out.println("getPath:" + file.getPath()); // test.txt
        System.out.println("getName:" + file.getName()); // test.txt
        System.out.println("length:" + file.length()); // 0
        System.out.println("lastModified:" + file.lastModified()); // 1491468425566

        // 1491468425566
        Date d = new Date(1491468425566L);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);
    }
}

/*
 * 高级获取功能：
 */
public class FileDemo {
    public static void main(String[] args) {
        // 指定一个目录
        File file = new File("G:\\");

        // public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
        String[] strArray = file.list();
        for (String s : strArray) {
            System.out.println(s);
        }
        System.out.println("------------");

        // public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组
        File[] fileArray = file.listFiles();
        for (File f : fileArray) {
            System.out.println(f.getName());
        }
    }
}