public class Singleton {
private static Singleton uniqueInstance;
private Singleton(){
}
public static Singleton getInstance(){
if(uniqueInstance == null){
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
}
这样就保证始终是一个实例，不过它还有一些问题。
书上的小例子，巧克力炉子
//巧克力炉
public class ChocolateBoiler {
//空
private boolean empty;
//煮沸
private boolean boiled;
private static ChocolateBoiler one;
private ChocolateBoiler(){
empty = true;
boiled = false;
}
public boolean isEmpty(){
return empty;
}
public boolean isBoiled(){
return boiled;
}
//填满
public void fill(){
if(isEmpty()){
empty = false;
boiled = false;
System.out.println("填满成功");
}
}
//排除
public void drain(){
if(!isEmpty()&&isBoiled()){
empty = true;
System.out.println("排除成功");
}
}
//煮沸
public void boil(){
if(!isEmpty()&&!isBoiled()){
boiled = true;
System.out.println("煮沸成功");
}
}
public static ChocolateBoiler getChocolateBoiler(){
if(one == null){
one = new ChocolateBoiler();
}
return one;
}
}
去建立一个运行测试
public class MainRun {
public static void main(String[] args) {
// TODO Auto-generated method stub
ChocolateBoiler oneb = ChocolateBoiler.getChocolateBoiler();
ChocolateBoiler twob = ChocolateBoiler.getChocolateBoiler();
oneb.fill();
twob.boil();
oneb.drain();
}
}
两个句柄都在同时操作一个实例。
刚才提到的小问题就是线程的问题，假如在未创建实例的情况下 同时有两个线程调用了get（）方法 就会有可能创建两个实例
那么简单的解决方法就是加上synchronized 同步，这样可以让一个线程执行完方法后才能下一个线程进入
public static synchronized ChocolateBoiler getChocolateBoiler()但是这个的话会降低性能至少100倍，而且只有第一次执行的时候需要同步，之后的话并不需要，所以之后每一次调用都有同步来影响性能。
解决办法一：
可以初始就让 锅炉有初始值 这样的方式也叫 饿汉式 之前写的 可以叫懒汉式，也可以叫懒加载
private static ChocolateBoiler one = new ChocolateBoiler();解决方法二：
如果程序要不高的话也可以就用同步
解决方法三：
双重检查加锁
//巧克力炉
public class ChocolateBoiler {
//空
private boolean empty;
//煮沸
private boolean boiled;
//volatile修饰符
private volatile static ChocolateBoiler one;
private ChocolateBoiler(){
empty = true;
boiled = false;
}
public boolean isEmpty(){
return empty;
}
public boolean isBoiled(){
return boiled;
}
//填满
public void fill(){
if(isEmpty()){
empty = false;
boiled = false;
System.out.println("填满成功");
}
}
//排除
public void drain(){
if(!isEmpty()&&isBoiled()){
empty = true;
System.out.println("排除成功");
}
}
//煮沸
public void boil(){
if(!isEmpty()&&!isBoiled()){
boiled = true;
System.out.println("煮沸成功");
}
}
public static synchronized ChocolateBoiler getChocolateBoiler(){
if(one == null){
synchronized (ChocolateBoiler.class) {
if(one == null){
one = new ChocolateBoiler();
}
}
}
return one;
}
}
Volatile关键字
Java语言提供了一种稍弱的同步机制，即volatile变量，用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。
在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。
当对非 volatile 变量进行读写的时候，每个线程先从内存拷贝变量到CPU缓存中。如果计算机有多个CPU，每个线程可能在不同的CPU上被处理，这意味着每个线程可以拷贝到不同的 CPU cache 中。
而声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读，跳过 CPU cache 这一步。
当一个变量定义为 volatile 之后，将具备两种特性：
1.保证此变量对所有的线程的可见性，这里的“可见性”，如本文开头所述，当一个线程修改了这个变量的值，volatile 保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新。但普通变量做不到这点，普通变量的值在线程间传递均需要通过主内存（详见：Java内存模型）来完成。
2.禁止指令重排序优化。有volatile修饰的变量，赋值后多执行了一个“load addl $0x0, (%esp)”操作，这个操作相当于一个内存屏障（指令重排序时不能把后面的指令重排序到内存屏障之前的位置），只有一个CPU访问内存时，并不需要内存屏障；（什么是指令重排序：是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理）。
volatile 性能：
volatile 的读性能消耗与普通变量几乎相同，但是写操作稍慢，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。