@Override
 public synchronized StringBuffer append(String str) {
     toStringCache = null;
     super.append(str);
     return this;
 }

private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");

//线程调用方法
private static void update() {
    try {
        simpleDateFormat.parse("20180208");
    } catch (Exception e) {
        log.error("parse exception", e);
    }
}

private static void update() {
    try {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
        simpleDateFormat.parse("20180208");
    } catch (Exception e) {
        log.error("parse exception", e);
    }
}

private static DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyyMMdd");

private static void update(int i) {
    log.info("{}, {}", i, DateTime.parse("20180208", dateTimeFormatter).toDate());
}

package cn.northpark.concurrency.publish;

import java.util.Arrays;

import cn.northpark.concurrency.annotaion.NotRecommand;
import cn.northpark.concurrency.annotaion.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

/**
 * @author jeyy
 *	这个代码通过public访问级别发布了类的域，在类的任何外部的线程都可以访问这些域
 *  我们无法保证其他线程会不会修改这个域，从而使私有域内的值错误（上述代码中就对私有域进行了修改）
 */
@Slf4j
@NotThreadSafe
@NotRecommand
public class UnsafePublish {

	//调用类的公共方法可以改变类的私有属性的值
	private String[] status = {"1","2","3"};
	
	//类的非私有方法，返回私有对象的引用
	public String[] getStatus() {
		return status;
	}
	
	public static void main(String[] args) {
		UnsafePublish up = new UnsafePublish();
		log.info("{}",Arrays.toString(up.getStatus()));
		
		up.status[0]="999";
		log.info("{}",Arrays.toString(up.getStatus()));
		
	}
}

package cn.northpark.concurrency.publish;

import cn.northpark.concurrency.annotaion.NotRecommand;
import cn.northpark.concurrency.annotaion.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

/**
 * @author jeyy
 *  <pre>
 *  这个内部类的实例里面包含了对封装实例的私有域对象的引用，在对象没有被正确构造完成之前就会被发布，有可能有不安全的因素在里面，会导致this引用在构造期间溢出的错误。
 *  上述代码在函数构造过程中启动了一个线程。无论是隐式的启动还是显式的启动，都会造成这个this引用的溢出。新线程总会在所属对象构造完毕之前就已经看到它了。
 *  因此要在构造函数中创建线程，那么不要启动它，而是应该采用一个专有的start或者初始化的方法统一启动线程
 *  这里其实我们可以采用工厂方法和私有构造函数来完成对象创建和监听器的注册等等，这样才可以避免错误
 *  ——————————————————————————————————————————————————-
 *  如果不正确的发布对象会导致两种错误： 
 *  （1）发布线程意外的任何线程都可以看到被发布对象的过期的值 
 *  （2）线程看到的被发布线程的引用是最新的，然而被发布对象的状态却是过期的
 * </pre>	
 */
@Slf4j
@NotThreadSafe
@NotRecommand
public class Escape {

	private int thisCanBeEscape = 0;
	
	public Escape() {
		new InnerClass();
	}
	
	public class InnerClass{
		//内部类构造方法调用外部类的私有域
		public InnerClass() {
			log.info("{}",Escape.this.thisCanBeEscape);
		}
	}
	
	public static void main(String[] args) {
		new Escape();
	}
}

//ThreadLocal的get方法源码
public T get() {
    Thread t = Thread.currentThread();//当前线程对象
    ThreadLocalMap map = getMap(t);//get操作基于当前线程
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

package cn.northpark.concurrency.immutable;

import java.util.Map;

import com.google.common.collect.Maps;

import cn.northpark.concurrency.annotaion.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@NotThreadSafe
public class ImmutableExample1 {

    private final static Integer a = 1;
    private final static String b = "2";
    private final static Map<Integer, Integer> map = Maps.newHashMap();

    static {
        map.put(1, 2);
        map.put(3, 4);
        map.put(5, 6);
    }

    public static void main(String[] args) {
        //a = 2;//报错
        //b = "3";//报错
        //map = Maps.newHashMap();//报错
        map.put(1, 3);
        log.info("{}", map.get(1));
    }

    private void test(final int a) {
//        a = 1;
    }
}

private void test(final int a) {
//        a = 1;	//报错
    }

package cn.northpark.concurrency.atomic;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

import cn.northpark.concurrency.annotaion.ThreadSafe;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@ThreadSafe
public class TestAtomicInteger {

	// 请求总数
	static int totalCount = 5000;

	// 同时并发执行的线程数
	static int threadTotal = 200;

	// 计数器
	public static AtomicInteger count = new AtomicInteger(0);

	public static void main(String[] args) throws InterruptedException {
		ExecutorService executorService = Executors.newCachedThreadPool();
		// 限制同时执行的线程数
		final Semaphore semaphore = new Semaphore(threadTotal);
		final CountDownLatch countDownLatch = new CountDownLatch(totalCount);

		for (int i = 0; i < totalCount; i++) {
			executorService.execute(() -> {
				try {
					semaphore.acquire();
					add();
					semaphore.release();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				countDownLatch.countDown();

			});
		}

		countDownLatch.await();
		executorService.shutdown();
		log.info("count{}", count);
	}

	public static void add() {
		count.incrementAndGet();
		// count.getAndIncrement();
	}
}