并发：多个线程操作相同的资源，保证线程安全，合理使用资源
高并发：服务能同时处理很多请求，提高程序性能
线程安全性
CAS=compareAndSwap，拿当前对象的值和底层的值进行对比，前对象的值和底层的值一致时执行对应的操作，不一样就不停取最新的值，直到相同的时候才执行操作。
CAS 死循环内不断尝试修改目标值直到修改成功，如果竞争不激烈的时候修改成功概率很高。竞争激烈的时候修改失败的概率很高，不断尝试就会影响性能。
long，double jvm 允许将64位的读操作或者写操作拆成2个32位的操作。
LongAdder的实现思想：热点数据分离。把atomicLong value分离为数组，每个线程访问时通过hash等算法映射到其中一个数组计数，最终的计数结果是数组的求和累加，热点数据value就被分离成多个单元，提高了并行度。高并发分散提高性能，但准确度会有偏差。
序列号生成的情况，准确的数值的情况，全局统一计数的情况还是应该选择atomic
synchronized和Atomic比较重要
可见性
volatile不具备原子性，使用条件：
对变量的写操作不依赖于当前值
该变量没有包含在具有其他变量的不变式子中
适合作为状态标记量，和双重检测（单例模式）
有序性
安全发布对象
单例模式
/**
* 懒汉模式
* 单例的实例在第一次使用时创建
* 线程不安全
*/
public class SingletonExample1 {
//私有构造函数
private SingletonExample1(){
}
//单例对象
private static SingletonExample1 instance = null;
//静态的工厂方法
public static SingletonExample1 getInstance(){
if(instance == null){
instance = new SingletonExample1();
}
return instance;
}
}
/**
* 懒汉模式
* 单例的实例在第一次使用时创建
* 线程安全
*/
public class SingletonExample3 {
//私有构造函数
private SingletonExample3(){
}
//单例对象
private static SingletonExample3 instance = null;
//静态的工厂方法
public static synchronized SingletonExample3 getInstance(){
if(instance == null){
instance = new SingletonExample3();
}
return instance;
}
}
/**
* 懒汉模式 --- 双重同步锁单例模式
* 单例的实例在第一次使用时创建
* 线程不安全
*/
public class SingletonExample4 {
//私有构造函数
private SingletonExample4(){
}
// 1、memory = allocate() 分配内存空间
// 2、ctorInstance() 初始化对象
// 3、instance = memory 设置instance指向刚分配的内存
//JVM和cpu优化，发生了指令重排
// 1、memory = allocate() 分配内存空间
// 3、instance = memory 设置instance指向刚分配的内存
// 2、ctorInstance() 初始化对象
//单例对象
private static SingletonExample4 instance = null;
//静态的工厂方法
public static SingletonExample4 getInstance(){
if(instance == null){ //双重检测机制
synchronized(SingletonExample4.class){//同步锁
if(instance == null) {
instance = new SingletonExample4();
}
}
}
return instance;
}
}
/**
* 懒汉模式 --- 双重同步锁单例模式
* 单例的实例在第一次使用时创建
* 线程安全
*/
public class SingletonExample5 {
//私有构造函数
private SingletonExample5(){
}
// 1、memory = allocate() 分配内存空间
// 2、ctorInstance() 初始化对象
// 3、instance = memory 设置instance指向刚分配的内存
//JVM和cpu优化，发生了指令重排
// 1、memory = allocate() 分配内存空间
// 3、instance = memory 设置instance指向刚分配的内存
// 2、ctorInstance() 初始化对象
//单例对象 volatile + 双重检测机制 -> 禁止指令重排
private volatile static SingletonExample5 instance = null;
//静态的工厂方法
public static SingletonExample5 getInstance(){
if(instance == null){ //双重检测机制
synchronized(SingletonExample5.class){//同步锁
if(instance == null) {
instance = new SingletonExample5();
}
}
}
return instance;
}
}
/**
* 饿汉模式
* 单例的实例在类装载时创建
* 线程安全
*/
public class SingletonExample2 {
//私有构造函数
private SingletonExample2(){
}
//单例对象
private static SingletonExample2 instance = new SingletonExample2();
//静态的工厂方法
public static SingletonExample2 getInstance(){
return instance;
}
}
/**
* 饿汉模式
* 单例的实例在类装载时创建
* 线程安全
*/
public class SingletonExample6 {
//私有构造函数
private SingletonExample6(){
}
//单例对象
private static SingletonExample6 instance = null;
static{
instance = new SingletonExample6();
}
//静态的工厂方法
public static SingletonExample6 getInstance(){
return instance;
}
public static void main(String[] args) {
System.out.println(getInstance().hashCode());
System.out.println(getInstance().hashCode());
}
}
/**
* 枚举模式：最安全，推荐使用
* @author WangCH
* @create 2018-03-21 21:23
*/
public class SingletonExample7 {
private SingletonExample7(){
}
public static SingletonExample7 getInstance(){
return Singleton.INSTANCE.getInstance();
}
private enum Singleton{
INSTANCE;
private SingletonExample7 singletonExample7;
//JVM保证绝对只被调用1次
Singleton(){
singletonExample7 = new SingletonExample7();
}
public SingletonExample7 getInstance() {
return singletonExample7;
}
}
}
