线程同步与锁定_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;
    }
}