/*
这是一个单例模式的例子,单例模式意味着只能创建类中的一个对象,想要做到这点,需要3步实现:
1.将构造函数私有化,使其他class不能直接创建对象。
2.在单例的类中创建一个静态,私有的本类对象。
3.创建一个公有的获取对象方法。
*/
//方法一
//student一进内存,对象已经创建好了
//此方法简单易用,开发常用
class Student
{
private int age;
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
private Student(){}
private static Student student = new Student();
public static Student getStudnet(){
return student;
}
}
//这种方法只有在调用getStudnet()方法时才会创建对象
//方法二
class Student
{
private int age;
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
private Student(){}
private static Student student =null;
public static Student getStudnet(){
if(student==null)
student= new Student();
return student;
}
}
第二种方法虽然看上去好,但在多个线程调用时会发生死锁的问题例如线程a到了if(student==null)时停下,这时线程b也走到了if(student==null),然后a和b再往下执行时发现都可以创建新对象,这就违背了单例设计模式的思想,所以这时我们会用synchronized关键字给线程加一个锁,使得只有一个线程可以创建对象,语句如下:
public static synchronized Student getStudnet(){
if(student==null)
student= new Student();
return student;
}
但加入了synchronized会影响该方法的执行效率,所以我们还有一种写法,减少synchronized对执行效率的影响,语句如下:
public static synchronized Student getStudnet(){
if (student==null)
{
synchronized(Student.class)
{
if (student==null)
{
student= new Student();
}
}
}
return student;
}
这样的话可以避免总用synchronized关键字判断,保证此方法的效率。
class SingleDemo
{
public static void main(String[] args)
{
Student.getStudnet();
}
}
这是一个单例模式的例子,单例模式意味着只能创建类中的一个对象,想要做到这点,需要3步实现:
1.将构造函数私有化,使其他class不能直接创建对象。
2.在单例的类中创建一个静态,私有的本类对象。
3.创建一个公有的获取对象方法。
*/
//方法一
//student一进内存,对象已经创建好了
//此方法简单易用,开发常用
class Student
{
private int age;
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
private Student(){}
private static Student student = new Student();
public static Student getStudnet(){
return student;
}
}
//这种方法只有在调用getStudnet()方法时才会创建对象
//方法二
class Student
{
private int age;
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
private Student(){}
private static Student student =null;
public static Student getStudnet(){
if(student==null)
student= new Student();
return student;
}
}
第二种方法虽然看上去好,但在多个线程调用时会发生死锁的问题例如线程a到了if(student==null)时停下,这时线程b也走到了if(student==null),然后a和b再往下执行时发现都可以创建新对象,这就违背了单例设计模式的思想,所以这时我们会用synchronized关键字给线程加一个锁,使得只有一个线程可以创建对象,语句如下:
public static synchronized Student getStudnet(){
if(student==null)
student= new Student();
return student;
}
但加入了synchronized会影响该方法的执行效率,所以我们还有一种写法,减少synchronized对执行效率的影响,语句如下:
public static synchronized Student getStudnet(){
if (student==null)
{
synchronized(Student.class)
{
if (student==null)
{
student= new Student();
}
}
}
return student;
}
这样的话可以避免总用synchronized关键字判断,保证此方法的效率。
class SingleDemo
{
public static void main(String[] args)
{
Student.getStudnet();
}
}