并发与多线程

         public enum State {
                NEW
                    尚未开始的线程处于此状态，即刚创建线程对象，未调用start()方法
      
                RUNNABLE
                    新建线程调用start()方法后，在Java虚拟机中执行的线程处于此状态，但它可能正在等待来自操作系统的其他资源（如处理器）。
                          
                BLOCKED
                    处于阻塞状态的线程正在等待监视器锁定进入同步块或同步方法，或者重入锁进入同步块或同步方法
                 后调用Object.wait()方法
  
                WAITING
                     由于调用以下方法之一，线程处于等待状态
                        Object.wait(); 无超时
                        Thread.join(); 无超时
                        LockSupport.park();
                     例如，a.在对象上调用Object.wait（）的线程正在等待另一个线程调用Object.notify（）或Object.notifyAll（）在该对象。
                          b.一个名为Thread.join（的线程正在等待指定的线程终止。
                              
                TIMED_WAITING
                      由于调用一个线程，线程处于定时等待状态,使线程处于定时等待状态可调用方法如下：
                         Thread.sleep(long);
                         Object.wait(long)
                         Thread.join(long);
                         LockSupport.parkNanos(long);
                         LockSupport.parkUntil(long);

                TERMINATED
                    终止线程的线程状态。 即线程已完成当前任务的执行。
         }

    public  class InstanceObjectSyncronizedTest{
         private Integer  num = 5;
           
         public syncronized Integer getNum(){
                num++
                return num;
         }
    }
    

    public  class InstanceObjectSyncronizedTest{
          private static Integer  num = 5;
          
          public static synchronized  void IntegergetNum() {
                  ++num; 
          }
    }
    

@ThreadSafe
public class DoubleCheckLazySingleton {

   private static volatile DoubleCheckLazySingleton instance;

   public DoubleCheckLazySingleton getInstance(){
   	    if(instance == null){
   	    	synchronized (DoubleCheckLazySingleton.class){
   	    		if(instance == null){
   	    			instance = new DoubleCheckLazySingleton();
				}
			}
		}
   	    return instance;
   }

   DoubleCheckLazySingleton(){}

}

         public static class CallerRunsPolicy implements RejectedExecutionHandler {
            /**
             * Creates a {@code CallerRunsPolicy}.
             */
            public CallerRunsPolicy() { }
    
            /**
             * Executes task r in the caller's thread, unless the executor
             * has been shut down, in which case the task is discarded.
             *
             * @param r the runnable task requested to be executed
             * @param e the executor attempting to execute this task
             */
            public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                if (!e.isShutdown()) {
                    r.run();
                }
            }
         }

         /**
         * A handler for rejected tasks that throws a
         * {@code RejectedExecutionException}.
         */
          public static class AbortPolicy implements RejectedExecutionHandler {
            /**
             * Creates an {@code AbortPolicy}.
             */
            public AbortPolicy() { }
    
            /**
             * Always throws RejectedExecutionException.
             *
             * @param r the runnable task requested to be executed
             * @param e the executor attempting to execute this task
             * @throws RejectedExecutionException always
             */
            public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                throw new RejectedExecutionException("Task " + r.toString() +
                                                     " rejected from " +
                                                     e.toString());
            }
        }

/**
         * A handler for rejected tasks that silently discards the
         * rejected task.
         */
public static class DiscardPolicy implements RejectedExecutionHandler {
    /**
     * Creates a {@code DiscardPolicy}.
     */
    public DiscardPolicy() {
    }

    /**
     * Does nothing, which has the effect of discarding task r.
     *
     * @param r the runnable task requested to be executed
     * @param e the executor attempting to execute this task
     */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}

         /**
         * A handler for rejected tasks that discards the oldest unhandled
         * request and then retries {@code execute}, unless the executor
         * is shut down, in which case the task is discarded.
         */
         public static class DiscardOldestPolicy implements RejectedExecutionHandler {
            /**
             * Creates a {@code DiscardOldestPolicy} for the given executor.
             */
            public DiscardOldestPolicy() { }
    
            /**
             * Obtains and ignores the next task that the executor
             * would otherwise execute, if one is immediately available,
             * and then retries execution of task r, unless the executor
             * is shut down, in which case task r is instead discarded.
             *
             * @param r the runnable task requested to be executed
             * @param e the executor attempting to execute this task
             */
            public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                if (!e.isShutdown()) {
                    e.getQueue().poll();
                    e.execute(r);
                }
            }
         }