public class VolatileTest {
	public static void main(String[] args) throws InterruptedException {

		System.out.println("可见性测试");
		MyData myData = new MyData(); // 资源类

		//AA线程
		new Thread(() -> {
			System.out.println(Thread.currentThread().getName() + "\t come in");

			try {
				TimeUnit.SECONDS.sleep(3);  // 三秒种后把值改为60
				myData.addTo60(); 
			} catch (Exception e) {
			}
		}, "AAA").start();

		
		// main线程
		while (myData.number == 0) {
			// main线程持有共享数据的拷贝，一直为0
			// AA线程队变量的修改 main线程不可见
			// System.out.println(myData.number); // 不要用System.out.println调试
		}
		System.out.println(
				Thread.currentThread().getName() + "\t mission is over. main get number value: " + myData.number);
	}
}

public void println(int x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

// 多线程下flag=true可能先执行，还没走到a=1就被挂起。其它线程进入method02的判断，修改a的值=5，而不是6。
public void method01() {
		a = 1;
		flag = true;
	}

public void method02() {
	if (flag) {
		a += 5;
		System.out.println("*****retValue: " + a);
	}
}

for (int i = 0; i < 20; i++) {
	new Thread(() -> {
		for (int j = 0; j < 1000; j++) {
			test.addPlusPlus();
		}
	},String.valueOf(i)).start();
}

public void addPlusPlus(){
    a++; // a = a + 1
}

i++;

getfield  // i的值进栈 
iconst_1  // 1进栈
iadd  // 栈顶两元素相加
putfield  // 结果再给i

/**
 * 双检锁/双重校验锁（DCL，即 double-checked locking）
 *
 */
public class SingletonPattermDemo05 {

	private volatile static SingletonPattermDemo05 instance; // ！！volatile修饰 因为 new 实际上分为好几步

	private SingletonPattermDemo05() {
	}

	public static SingletonPattermDemo05 getInstance() {

		if (instance == null) { // 先判断一次 看是否需要加锁
			synchronized (SingletonPattermDemo05.class) {
				if (instance == null) { // 再判断一次 看实例是否需要创建

					/**
					 * 对象的实例化，并不是一步完成的，而是分为多步：
					 * 
					 * 1、申请内存空间，并且默认初始化（赋0值，半初始化）
					 * 
					 * 2、调用构造方法，进行初始化
					 * 
					 * 3、引用指向分配的地址空间
					 * 
					  *  如果不用volatile 2、3可能重排序
					 */
					instance = new SingletonPattermDemo05();
				}

			}
		}
		return instance;
	}

	public static void main(String[] args) {
		for (int i = 0; i < 1000; i++) {
			new Thread(() -> {
				System.out.println(Thread.currentThread().getName() + ":" + SingletonPattermDemo05.getInstance());
			}, String.valueOf(i)).start();
		}
	}
}

/**
     * The array of bins. Lazily initialized upon first insertion.
     * Size is always a power of two. Accessed directly by iterators.
     */
    transient volatile Node<K,V>[] table;

    /**
     * The next table to use; non-null only while resizing.
     */
    private transient volatile Node<K,V>[] nextTable;

AtomicInteger atomicInteger = new AtomicInteger(10);
System.out.println(atomicInteger.compareAndSet(10, 2020) +"\t current data : "+ atomicInteger.get());	
System.out.println(atomicInteger.compareAndSet(10, 2021)+"\t current data : "+ atomicInteger.get());

//true	 current data : 2020
//false	 current data : 2020

User user1 = new User("Jack",25);
User user2 = new User("Lucy",21);
AtomicReference<User> atomicReference = new AtomicReference<>();
atomicReference.set(user1);
System.out.println(atomicReference.compareAndSet(user1,user2)); // true
System.out.println(atomicReference.compareAndSet(user1,user2)); //false

// The synchronization state.
private volatile int state;
// 这些方法都是原子操作
getState()
setState()
compareAndSetState()

/** 
     * AbstractQueuedSynchronizer类的静态内部类
     * 资源共享模式的定义(队列中的Node)
     * 通过Node可以实现两个队列 一个借助prev和next线程同步队列(双向队列)，
     * 一个是借助nextWaiter实现的等待队列(单向队列 等待条件)
     */
    static final class Node {
        /** 共享模式 */
        static final Node SHARED = new Node();
        /** 独享模式 */
        static final Node EXCLUSIVE = null;

        /** timeout or interrupt 之后的该线程结点状态 */
        static final int CANCELLED =  1;
        /** 表示后继结点需要被唤醒 */
        static final int SIGNAL    = -1;
        /** 表示该结点（对应的线程）在等待某一条件 */
        static final int CONDITION = -2;
        /**
         * waitStatus value to indicate the next acquireShared should
         * unconditionally propagate
         * 表示有资源可用，新head结点需要继续唤醒后继结点(共享模式下，多线程并发释放资源，而head唤醒其后继结点后，需要把多出来的资源留给后面的结点；设置新的head结点时，会继续唤醒其后继结点)
         */
        static final int PROPAGATE = -3;
        volatile int waitStatus;
        volatile Node prev;
        volatile Node next;

        /**
         * 该节点对应的线程.  Initialized on
         * construction and nulled out after use.
         */
        volatile Thread thread;

        /**
         * Link to next node waiting on condition, or the special
         * value SHARED.  Because condition queues are accessed only
         * when holding in exclusive mode, we just need a simple
         * linked queue to hold nodes while they are waiting on
         * conditions. They are then transferred to the queue to
         * re-acquire. And because conditions can only be exclusive,
         * we save a field by using special value to indicate shared
         * mode.
         */
        Node nextWaiter;

        /**
         * 判断共享模式的方法
         * Returns true if node is waiting in shared mode.
         */
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        /**
         * Returns previous node, or throws NullPointerException if null.
         * Use when predecessor cannot be null.  The null check could
         * be elided, but is present to help the VM.
         */
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        Node() {    // Used to establish initial head or SHARED marker
        }

        Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

// 子类可以重写的方法
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}
// 模板方法
public final void acquire(int arg) {
    // 如果获取资源失败，即tryAcquire(arg)返回flase，！!tryAcquire(arg) 为true，&&后面的方法会执行 将当前线程加入到等待队列尾部中，然后再等待队列头部拿一个正在等待的线程，之后再中断当前线程
    // 如果获取资源成功，即tryAcquire(arg)返回true，！!tryAcquire(arg) 为false，&&后面的方法不会执行
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))  
        selfInterrupt();
}

private Node addWaiter(Node mode) {
    // 生成该线程对应的Node节点
    Node node = new Node(Thread.currentThread(), mode);
    // 将Node插入队列中
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        // 使用CAS尝试，如果成功就返回
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 如果等待队列为空或者上述CAS失败，再自旋CAS插入
    enq(node);
    return node;
}

// 自旋CAS插入等待队列
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

public static void main(String[] args) throws InterruptedException {
		
		Thread t1 = new Thread(()-> {
			System.out.println("线程一");
		});
		
		Thread t2 = new Thread(()-> {
			System.out.println("线程二");
		});
		
		t1.start();
		t2.start();	
		
		t1.join();
		t2.join();
		
		
		System.out.println("主线程");
	}

    /**
     * 线程一 
     * 线程二
     * 主线程
     * 一二行的位置可能不一样，当第三行一定在前两行后执行
     */

// ClearInterrupted参数来决定要不要重置中断标志位
private native boolean isInterrupted(boolean ClearInterrupted);

public boolean isInterrupted() {

    // ClearInterrupted参数为false, 说明它仅仅返回线程实例的中断状态，但是不会对现有的中断状态做任何改变
    return isInterrupted(false);
}

// 在返回线程中断状态的同时，重置了中断标识位为false
public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

 /* Java thread status for tools,
  * initialized to indicate thread 'not yet started'
  */

    private volatile int threadStatus = 0;

    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        group.add(this);
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

 /**
     * Returns the state of this thread.
     * This method is designed for use in monitoring of the system state,
     * not for synchronization control.
     *
     * @return this thread's state.
     * @since 1.5
     */
    public State getState() {
        // get current thread state
        return sun.misc.VM.toThreadState(threadStatus); 
    }

public static State toThreadState(int var0) {
    if ((var0 & 4) != 0) { // threadStatus==4 RUNNABLE
        return State.RUNNABLE;
    } else if ((var0 & 1024) != 0) { // threadStatus==1024 BLOCKED
        return State.BLOCKED;
    } else if ((var0 & 16) != 0) { // threadStatus==16 WAITING
        return State.WAITING;
    } else if ((var0 & 32) != 0) { //threadStatus==32 TIMED_WAITING
        return State.TIMED_WAITING;
    } else if ((var0 & 2) != 0) { //threadStatus==2 TERMINATED
        return State.TERMINATED;
    } else {
        // 如果threadStatus==0 0&1==0 所以此方法返回 State.NEW
        // 如果threadStatus!=0(可能等于2、4、16、32、1024) 0&1==0 所以此方法返回 State.RUNNABLE 此索引值为1
        return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE; // threadStatus==0 NEW
    }
}

@Override
public void run() {
    try {
        // 1. isInterrupted() 用于终止一个正在运行的线程。
        while (!isInterrupted()) {
            // 执行任务...
        }
    } catch (InterruptedException ie) {  
        // 2. InterruptedException异常用于终止一个处于阻塞状态的线程
    }
}

// 关键字在代码块上，锁为括号里面的对象
public void blockLock01() {
    Object o = new Object();
    synchronized (o) {
        // code
    }
}

// 关键字在代码块上，锁为括号里面的对象
public void blockLock02() {
    synchronized (this.getClass()) {
        // code
    }
}

// 关键字在实例方法上，锁为当前实例
public synchronized void instanceLock() {
    // code
}

// 关键字在静态方法上，锁为当前Class对象
public static synchronized void classLock() {
    // code
}

//javac -encoding utf-8 XXX.java
//javap -c XXX.class
public void blockLock01();
    Code:
       0: new           #2                  // class java/lang/Object
       3: dup
       4: invokespecial #1                  // Method java/lang/Object."<init>":()V
       7: astore_1
       8: aload_1
       9: dup
      10: astore_2
      11: monitorenter
      12: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      15: ldc           #4                  // String 同步代码块
      17: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      20: aload_2
      21: monitorexit
      22: goto          30
      25: astore_3
      26: aload_2
      27: monitorexit
      28: aload_3
      29: athrow
      30: return
    Exception table:
       from    to  target type
          12    22    25   any
          25    28    25   any

public interface BlockingQueue<E> extends Queue<E> {

    //将给定元素设置到队列中，如果设置成功返回true, 否则返回false。如果是往限定了长度的队列中设置值，推荐使用offer()方法。
    boolean add(E e);

    //将给定的元素设置到队列中，如果设置成功返回true, 否则返回false. e的值不能为空，否则抛出空指针异常。
    boolean offer(E e);

    //将元素设置到队列中，如果队列中没有多余的空间，该方法会一直阻塞，直到队列中有多余的空间。
    void put(E e) throws InterruptedException;

    //将给定元素在给定的时间内设置到队列中，如果设置成功返回true, 否则返回false.
    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    //从队列中获取值，如果队列中没有值，线程会一直阻塞，直到队列中有值，并且该方法取得了该值。
    E take() throws InterruptedException;

    //在给定的时间里，从队列中获取值，时间到了直接调用普通的poll方法，为null则直接返回null。
    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;

    //获取队列中剩余的空间。
    int remainingCapacity();

    //从队列中移除指定的值。
    boolean remove(Object o);

    //判断队列中是否拥有该值。
    public boolean contains(Object o);

    //将队列中值，全部移除，并发设置到给定的集合中。
    int drainTo(Collection<? super E> c);

    //指定最多数量限制将队列中值，全部移除，并发设置到给定的集合中。
    int drainTo(Collection<? super E> c, int maxElements);
}

 public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
}

private E dequeue() {
    // assert lock.getHoldCount() == 1;
    // assert items[takeIndex] != null;
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex];
    items[takeIndex] = null;
    if (++takeIndex == items.length)
        takeIndex = 0;
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    notFull.signal();
    return x;
}

class ShareData { // 资源类
	private int number = 0;
	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();

	// 多线程判断用while

	public void increase() throws Exception {

		lock.lock();
		try {

			// 判断 多线程判断用while
			while (number != 0) {
				// 有资源 等待
				condition.await();
			}

			// 干活
			number++;
			System.out.println(Thread.currentThread().getName() + "\t" + number);

			// 通知
			condition.signalAll();

		} finally {
			lock.unlock();
		}
	}

	public void decrease() throws Exception {
		lock.lock();
		try {
			// 判断 多线程判断用while
			while (number == 0) {
				// 有资源 等待
				condition.await();
			}

			// 干活
			number--;
			System.out.println(Thread.currentThread().getName() + "\t" + number);

			// 通知
			condition.signalAll();
		} finally {
			lock.unlock();
		}
	}
}

/**
 * 
 *   一个初始为零的变量 两个线程对其交替操作 一个加1一个减1
 * 
 *   线程 操作 资源类 判断 干活 通知
 */
public class ProducerConsumer_TraditionDemo {

	public static void main(String[] args) {
		
		ShareData shareData = new ShareData();
		
		new Thread(()->{
			for (int i = 0; i < 5; i++) {
				try {
					shareData.increase();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		},"AA").start();
		
		new Thread(()->{
			for (int i = 0; i < 5; i++) {
				try {
					shareData.decrease();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		},"BB").start();
	}
}

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler){……}

// JDK 1.8 
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();   
    int c = ctl.get();
    // 1.当前线程数小于corePoolSize,则调用addWorker创建核心线程(需要获取mainlock这个全局锁)执行任务
    if (workerCountOf(c) < corePoolSize) {
       if (addWorker(command, true))
           return;
       c = ctl.get();
    }
    // 2.如果不小于corePoolSize，则将任务添加到workQueue队列。
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 2.1 如果isRunning返回false(状态检查)，则remove这个任务，然后执行拒绝策略。
        if (! isRunning(recheck) && remove(command))
            reject(command);
            // 2.2 线程池处于running状态，但是没有线程，则创建线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 3.如果放入workQueue失败，则创建(需要获取mainlock这个全局锁)非核心线程执行任务，
    // 如果这时创建非核心线程失败(当前线程总数不小于maximumPoolSize时)，就会执行拒绝策略。
    else if (!addWorker(command, false))
         reject(command);
}

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}