线程同步与锁定_synchronized_单例模式_doubleCheckingJAVA178-179

来源：http://www.bjsxt.com/
一、S02E178_01线程同步与锁定1_synchronized
——由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。
——由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块
——同步：并发，多个线程访问同一份资源(确保资源安全–>>线程安全)
1、同步块
——synchronized(引用类型或者this或者类.class){
}
2、同步方法
——synchronized

package com.test.thread.syn;public class SynDemo {    public static void main(String[] args) {        //真实角色        Web12306 web = new Web12306();        //代理        Thread t1 = new Thread(web, "路人甲");        Thread t2 = new Thread(web, "黄牛乙");        Thread t3 = new Thread(web, "攻城狮");        t1.start();        t2.start();        t3.start();    }}class Web12306 implements Runnable {    private int num = 10;//1到10号    private boolean flag = true;    @Override    public void run(){        while(flag) {            //test1();            //test2();            //test3();            //test4();            //test5();            test6();        }    }    //线程不安全    public void test1(){        if(num <= 0){            flag = false;//跳出循环            return;        }        try {            Thread.sleep(500);//模拟延时        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println(Thread.currentThread().getName() + "抢到了" + num--);    }    //同步方法，线程安全，锁定正确    public synchronized void test2(){        if(num <= 0){            flag = false;//跳出循环            return;        }        try {            Thread.sleep(500);//模拟延时        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println(Thread.currentThread().getName() + "抢到了" + num--);    }    //同步块，线程安全，锁定正确    public void test3(){        synchronized(this){            if(num <= 0){                flag = false;//跳出循环                return;            }            try {                Thread.sleep(500);//模拟延时            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println(Thread.currentThread().getName() + "抢到了" + num--);        }    }    //锁定范围不正确    public void test4(){        synchronized(this){            if(num <= 0){                flag = false;//跳出循环                return;            }        }        try {            Thread.sleep(500);//模拟延时        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println(Thread.currentThread().getName() + "抢到了" + num--);    }    //线程不安全，锁定资源不正确    public void test5(){        synchronized((Integer)num){            if(num <= 0){                flag = false;//跳出循环                return;            }            try {                Thread.sleep(500);//模拟延时            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println(Thread.currentThread().getName() + "抢到了" + num--);        }    }    //锁定范围不正确    public void test6(){        if(num <= 0){            flag = false;//跳出循环            return;        }        synchronized(this){            try {                Thread.sleep(500);//模拟延时            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println(Thread.currentThread().getName() + "抢到了" + num--);        }    }}

二、S02E179_01线程同步与锁定2_synchronized_单例模式_doubleChecking

package com.test.thread.syn;/** * 单例设计模式：外部使用时确保一个类只有一个对象（内部创建，外部不能创建，只能使用） */public class Singleton {    public static void main(String[] args) {        JvmThread thread1 = new JvmThread(100);        JvmThread thread2 = new JvmThread(100);        thread1.start();        thread2.start();    }}class JvmThread extends Thread{    private long time;    public JvmThread(){    }    public JvmThread(long time){        this.time = time;    }    @Override    public void run(){        System.out.println(Thread.currentThread().getName()+"-->"+Jvm.getInstance(time));    }}/** * 单例设计模式 * 外部使用时确保一个类只有一个对象（内部创建，外部不能创建，只能使用） * 懒汉式  double checking * 1、构造器私有化，避免外部直接创建对象 * 2、声明一个私有的静态变量 * 3、创建一个对外的公共的静态方法访问该变量，如果变量没有对象，创建该对象 */class Jvm{    //声明一个私有的静态变量    private static Jvm instance = null;//懒得创建对象    //构造器私有化，避免外部直接创建对象    private Jvm(){    }    //创建一个对外的公共的静态方法访问该变量，如果变量没有对象，创建该对象    //一、不同步，产生多个对象    public static Jvm getInstance1(long time){        if(null==instance){            try {                Thread.sleep(time);//延时，放大发生错误的概率            } catch (InterruptedException e) {                e.printStackTrace();            }            instance = new Jvm();        }        return instance;    }    //二、加入synchronized，成为同步方法，只有一个对象    public static synchronized Jvm getInstance2(long time){        if(null==instance){            try {                Thread.sleep(time);//延时，放大发生错误的概率            } catch (InterruptedException e) {                e.printStackTrace();            }            instance = new Jvm();        }        return instance;    }    //三、同步块，只有一个对象，效率不高，存在对象也需要等待    public static Jvm getInstance3(long time){        //a、b、c、d线程进来都需要等待，效率不高，存在对象也需要等待        synchronized(Jvm.class){//锁住类的字节码信息            if(null==instance){                try {                    Thread.sleep(time);//延时，放大发生错误的概率                } catch (InterruptedException e) {                    e.printStackTrace();                }                instance = new Jvm();            }            return instance;        }    }    //四、同步块，只有一个对象，doubleChecking提高已经存在对象的访问效率    public static Jvm getInstance(long time){        //第二段：后来c、d线程都进来判断，发现有对象，直接返回，不用等待        if(null==instance){            //第一段：刚开始a、b线程都进来等待，a进入创建对象后，b再进入后发现有对象就直接返回            synchronized(Jvm.class){//锁住类的字节码信息                if(null==instance){                    try {                        Thread.sleep(time);//延时，放大发生错误的概率                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    instance = new Jvm();                }            }        }        return instance;    }}

package com.test.thread.syn;/** * 单例创建的方式 * 1、懒汉式 *  1)构造器私有化 *  2)声明私有的静态属性 *  3)对外提供访问属性的静态方法，确保该对象存在 */public class MyJvm {    private static MyJvm instance;    private MyJvm(){    }    public static MyJvm getInstance(){        if(null==instance){//提高效率            synchronized(MyJvm.class){                if(null==instance){//安全                    instance = new MyJvm();                }            }        }        return instance;    }}/** * 饿汉式 *  1)构造器私有化 *  2)声明私有的静态属性，同时创建该对象 *  3)对外提供访问属性的静态方法，确保该对象存在 */class MyJvm2 {    private static MyJvm2 instance = new MyJvm2();    private MyJvm2(){    }    public static MyJvm2 getInstance(){        return instance;    }}/** * 类在使用时加载，延缓加载时机，提高效率 */class MyJvm3 {    private static class JvmHolder{//内部类，使用时加载        private static MyJvm3 instance = new MyJvm3();    }    private MyJvm3(){    }    public static MyJvm3 getInstance(){        return JvmHolder.instance;    }}