Java 线程同步(Synchronized)学习

线程同步(Synchronized):

• Synchronized作用

• 1Synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法或者代码块。
• 2同步的作用不仅仅是互斥，它的另一个作用就是共享可变性，当某个线程修改了可变数据并释放锁后，其它线程可以获取被修改变量的最新值。如果没有正确的同步，这种修改对其它线程是不可见的。

• Synchronized的三种使用方式:

• 1修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
  如 public Synchronized void method(){ //代码 }
• 2修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁
  如 public static Synchronized void Synchronized method(){ //代码 }
• 3修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。
  如 public void method(){
  Synchronized (一个引用类型,不能是基本数据类型){
  //同步的代码快
  }
  }

• 模拟一个单例模式(懒汉):

• 单线程情况下使用单例模式:

 	/**
 	 * 内部类
     * 模拟一个单例模式(懒汉模式)--->当前代码是单线程情况下获取的对象是同一个对象
     */
    static class Connection {
        private static Connection connection = null;
        private Connection() {
        }

        /**
         * 并发情况下保证只有一个对象:加入线程同步 synchronized方法或同步代码快
         *
         * @return
         */
        public  static Connection getConnection() {
            if (connection == null) {
                try {
                    //延迟创建
                    Thread.sleep(200);
                    connection = new Connection();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return connection;
        }
    }

	 public static void main(String[] args) {
        //单线程情况下使用单例模式
        Connection conn1 = Connection.getConnection();
        Connection conn2 = Connection.getConnection();
        System.out.println(conn1);
        System.out.println(conn2);
    }

结果:执行了十次还是一样
。。。Connection@6d6f6e28
。。。Connection@6d6f6e28

• 多线程情况下使用单例模式

    /**
     * 模拟一个单例模式(懒汉模式)--->当前代码是单线程情况下获取的对象是同一个对象
     */
    static class Connection {
        private static Connection connection = null;
        private Connection() { }
        public  static synchronized Connection getConnection() {
            if (connection == null) {
                try {
                    //延迟创建
                    Thread.sleep(200);
                    connection = new Connection();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return connection;
        }
    }


    /**
     * 在多线程情况下获取的对象就不一定是同一个对象了
     */
    static class ThreadConnection extends Thread{
        @Override
        public void run() {
            System.out.println("创建Connection对象:"+ Connection.getConnection());
        }
    }

  public static void main(String[] args) {
        /*
         *单线程情况下使用单例模式
        Connection conn1 = Connection.getConnection();
        Connection conn2 = Connection.getConnection();
        System.out.println(conn1);
        System.out.println(conn2);
        */

        //多线程情况下使用单例模式
        ThreadConnection threadConnection1 = new ThreadConnection();
        ThreadConnection threadConnection2= new ThreadConnection();
        threadConnection1.start();
        threadConnection2.start();
    }

结果:执行了三次
创建Connection对象:。。。Connection@2d3661a3
创建Connection对象:。。。Connection@42f5503f

• 加入同步锁synchronized()保证只存在一个对象

    public static void main(String[] args) {
        /*
         *单线程情况下使用单例模式
        Connection conn1 = Connection.getConnection();
        Connection conn2 = Connection.getConnection();
        System.out.println(conn1);
        System.out.println(conn2);
        */

        //多线程情况下使用单例模式
        ThreadConnection threadConnection1 = new ThreadConnection();
        ThreadConnection threadConnection2= new ThreadConnection();
        threadConnection1.start();
        threadConnection2.start();

    }


    /**
     * 模拟一个单例模式(懒汉模式)--->当前代码是单线程情况下获取的对象是同一个对象
     */
    static class Connection {
        private static Connection connection = null;
        private Connection() {
        }

        /**
         * 并发情况下保证只有一个对象:加入线程同步 synchronized方法或同步代码快
         *
         * @return
         */
        public  static synchronized Connection getConnection() {
            if (connection == null) {
                try {
                    //延迟创建
                    Thread.sleep(200);
                    connection = new Connection();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return connection;
        }
    }
    /**
     * 在多线程情况下获取的对象就不一定是同一个对象了
     */
    static class ThreadConnection extends Thread{
        @Override
        public void run() {
            System.out.println("创建Connection对象:"+ Connection.getConnection());
        }
    }

结果：不管执行多少次都是同一个对象

这篇文章写的不错,很细 https://blog.csdn.net/javazejian/article/details/72828483