单例模式有懒汉式和恶汉式设计模式有什么用    在什么时候用   请大神给个完整的解答    整体的概念有些模糊   

饿汉式:
class Single
{
        private String name;
        //1.将初始化构造函数私有化
        private Single(){};
        //2.在本类中创建一个本类对象
        private static Single s = new Single();
       //3.对外提供一个访问方法
        public static Single SingleInstance()
        {
                return s;
        }
}

懒汉式
class Singlee
{
        private static Singlee s = null;
        private Singlee(){}//私有
        public static Singlee SingleInstance()
        {
                if(s==null)//双重if判断
                {
                        synchronized(Singlee.class)//上锁
                        {
                                if(s==null)
                                {
                                        s = new Singlee();
                                }
                        }
                }
                return s;
        }
}

饿汉式与懒汉式的区别：
饿汉式先初始化对象，Single类一进入内存，就已经创建好了一个静态对象。
饿汉式特点：线程安全

懒汉式对象是被方法调用时，才初始化，也叫做对象的延时加载。
Single类进内存，对象还没有存在，只有调用了“SingleInstance方法时，才建立对象”
懒汉式特点：在创建实例对象时，如果不加上synchronized则会导致对对象的访问线程不安全

所以推荐使用饿汉式，懒汉式只要知道其特点就可以，面试的时候有可能会考到

路漫漫_求索 发表于 2014-5-22 14:27
饿汉式:
class Single
{

那这玩意到底是怎么个用法    什么情况下用  难道是满足它的条件就是要用它?

寻找人生目标 发表于 2014-5-22 14:34
那这玩意到底是怎么个用法    什么情况下用  难道是满足它的条件就是要用它? ...

当需要将该事物的对象在内存中唯一时，就将以上三步加上即可。例如下面代码：Studetn类（对一个特殊学生定义：唯一的学生）
class Student
{
        private int age;
        public void setAge(int age)
        {
                this.age=age;
        }
        public int getAge()
        {
                return age;
        }
        private Student(){}
        private static Student s = new Student();
        public static Student StudetnInstance()
        {
                return s;
        }
}


public class Singls {
       
        public static void main(String[] args)
        {

                Student d1 = Student.StudetnInstance();
                Student d2 = Student.StudetnInstance();

                //给d1赋值后，再打印d2的年龄；也是22，
                d1.setAge(22);
                System.out.println(d2.getAge());
               //结果是：22
        }

}

应该是在不希望其他程序建立建立本类对象，但同时有需要建立本类对象供其他程序使用的时候就要使用单例设计模式。

路漫漫_求索 发表于 2014-5-22 14:39
当需要将该事物的对象在内存中唯一时，就将以上三步加上即可。例如下面代码：Studetn类（对一个特殊学生 ...

谢谢               

就像这个生产者消费者问题，一边生产，一变消费。但他们操纵的是同一个对象，所以就需要这个对象唯一。在Resourse使用饿汉式创建了对象，在Producter和Consumer中获取这个对象操作它。
import java.util.concurrent.locks.*;
class ProducerConsumerDemo2
{
        public static void main(String[] args)
        {
                new Thread(new Producer()).start();
                new Thread(new Producer()).start();
                new Thread(new Consumer()).start();
                new Thread(new Consumer()).start();
        }
}
class Resourse
{
        private static final Resourse r=new Resourse();
        private Resourse(){}
        public static Resourse getRes(){
                return r;
        }
        private String name;
        private int count=0;
        private boolean state=true;
        private Lock lock=new ReentrantLock();
        private Condition condition_pro =lock.newCondition();
        private Condition condition_con =lock.newCondition();
        public void set(String name) throws InterruptedException
                {
                        lock.lock();
                        try
                        {
                                while(!state)
                                        condition_pro.await();
                                this.name=name+"-----"+count++;
                                System.out.println(Thread.currentThread().getName()+"。。。。生产者。。。"+this.name);
                                state=false;
                                condition_con.signal();
                        }
                        finally
                        {
                                lock.unlock();//释放锁的动作一定要执行
                        }
                }
        public void get() throws InterruptedException
                {
                        lock.lock();
                        try
                        {
                                while(state)
                                        condition_con.await();
                                System.out.println(Thread.currentThread().getName()+"。。。。消费者。。。。。。。。"+this.name);
                                state=true;
                                condition_pro.signal();
                        }
                        finally
                        {
                                lock.unlock();
                        }
                }
}
class Producer implements Runnable
{
        Resourse r=Resourse.getRes();
        public void run(){
                while(true)
                {
                        try
                        {
                                r.set("商品");
                        }
                        catch (InterruptedException e)
                        {
                        }
                }
        }
}
class Consumer implements Runnable
{
        Resourse r=Resourse.getRes();
        public void run(){
                while(true)
                {
                        try
                        {
                                r.get();
                        }
                        catch (InterruptedException e)
                        {
                        }
                }
        }
}

never615 发表于 2014-5-22 15:07
就像这个生产者消费者问题，一边生产，一变消费。但他们操纵的是同一个对象，所以就需要这个对象唯一。在Re ...

OK   明白了  谢谢