同步—Synchronized

1.为什么要使用synchronized

在并发编程中存在线程安全问题，主要原因有：
- 1.存在共享数据
- 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。

2.实现原理

synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。

3.synchronized的三种应用方式

Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

普通同步方法（实例方法），锁是当前实例对象，进入同步代码前要获得当前实例的锁；
静态同步方法，锁是当前类的class对象，进入同步代码前要获得当前类对象的锁；
同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

4.synchronized的作用

Synchronized是Java中解决并发问题的一种最常用最简单的方法，他可以确保线程互斥的访问同步代码。

5.举例子

Thread中的join()方法只会使主线程(或者说调用t.join()的线程)进入等待池并等待t线程执行完毕后才会被唤醒。并不影响同一时刻处在运行状态的其他线程。

一、synchronized作用于实例方法

①多个线程访问同一个对象的同一个方法：

public class synchronizedTest implements Runnable {
    //共享资源
    static int i =0;
    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase(){
        i++;
    }
    @Override
    public void run(){
        for (int j =0 ; j<10000;j++){
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        synchronizedTest test = new synchronizedTest();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

运行结果：

分析：当两个线程同时对一个对象的一个方法进行操作，只有一个线程能够抢到锁。因为一个对象只有一把锁，一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，就不能访问该对象的其他synchronized实例方法，需要等到对象被释放后才能获取，但是在对象没有被释放前，其他线程可以访问非synchronized修饰的方法

②一个线程获取了该对象的锁之后，其他线程来访问其他synchronized实例方法现象：

  public class SynchronizedTest {
      public synchronized void method1() {
          System.out.println("Method 1 start");
          try {
              System.out.println("Method 1 execute");
              Thread.sleep(3000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("Method 1 end");
      }

      public synchronized void method2() {
          System.out.println("Method 2 start");
          try {
              System.out.println("Method 2 execute");
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("Method 2 end");
      }


      public static void main(String[] args) {
          final SynchronizedTest test = new SynchronizedTest();

          new Thread(test::method1).start();

          new Thread(test::method2).start();
      }

  }

运行结果：

分析：可以看出其他线程来访问synchronized修饰的其他方法时需要等待线程1先把锁释放

③一个线程获取了该对象的锁之后，其他线程来访问其他非synchronized实例方法现象，去掉②中方法二的synchronized：

  public class SynchronizedTest {
      public synchronized void method1() {
          System.out.println("Method 1 start");
          try {
              System.out.println("Method 1 execute");
              Thread.sleep(3000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("Method 1 end");
      }

      public void method2() {
          System.out.println("Method 2 start");
          try {
              System.out.println("Method 2 execute");
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("Method 2 end");
      }


      public static void main(String[] args) {
          final SynchronizedTest test = new SynchronizedTest();

          new Thread(test::method1).start();
          new Thread(test::method2).start();
      }

  }

运行结果：

分析：当线程1还在执行时，线程2也执行了，所以当其他线程来访问非synchronized修饰的方法时是可以访问的

④当多个线程作用于不同的对象

    public class SynchronizedTest {
        public synchronized void method1() {
            System.out.println("Method 1 start");
            try {
                System.out.println("Method 1 execute");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 1 end");
        }

        public synchronized void method2() {
            System.out.println("Method 2 start");
            try {
                System.out.println("Method 2 execute");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 2 end");
        }


        public static void main(String[] args) {
            final SynchronizedTest test1 = new SynchronizedTest();
            final SynchronizedTest test2 = new SynchronizedTest();

            new Thread(test1::method1).start();

            new Thread(test2::method2).start();
        }

    }

运行结果：

分析：因为两个线程作用于不同的对象，获得的是不同的锁，所以互相并不影响

此处思考一个问题：为什么分布式环境下synchronized失效？如何解决这种情况？

synchronized关键字失效原因

在Java多线程编程中，经常会用到synchronized和lock和原子变量等，而在分布式系统中，由于分布式系统中的分布性，即多线程和多进程并发分布在不同机器中，synchronized和lock这两种锁将失去原有锁的效果，因此需要自己实现分布式锁来处理并发问题，分布式处理并发的办法有以下三种：

队列
- 定义：将所有要执行的任务放入队列中，然后一个一个消费，从而避免并发问题
悲观锁
- 将数据记录加版本号，如果版本号不一致就不更新，这种方式同Java的CAS理念类似。

分布式锁

常见的分布式锁有以下三种实现：

* 基于数据库实现的分布式锁
   利用数据库表：首先创建一张锁的表主要包含下列字段：方法名、时间戳等。——方法名称要有唯一性约束
      1、如果有多个请求同时提交到数据库时，数据库保证只有一个操作可以成功，那么操作成功的那个线程获得了该方法的锁，可以继续执行下面的方法体内容。
      优化： 记录当前获得该锁的机器的主机信息和线程信息，那么下次再次获取锁的时候就可以先查询数据库，如果当前机器的主机信息和线程信息可以在数据库中查到，那么就可以直接把锁分配给它，从而实现可重入锁。
      2、基于数据库排他锁
      在查询语句后面增加for update，数据库会在查询过程中给数据库表增加排他锁，当某条记录被加上排他锁之后，其他线程无法在该行记录增加排他锁。其他没有获取到的锁就会阻塞在select语句上，从而有两种可能的结果：
          * 在超时之前获取到了锁和在超时之前没有获取到锁。获得排他锁的线程即可获取分布式锁，当获取到锁之后，可以执行方法的业务逻辑，执行完方法之后，释放锁connection.commit()。
          * 存在的问题主要是性能不高和sql超时的异常。
          
* 基于Zookeeper实现分布式锁
   基于Zookeeper临时有序节点可以实现的分布式锁。每个客户端对某个方法加锁时，在Zookeeper上与该方法对应的指定节点的目录下，生成一个唯一的瞬时有序节点。
       * 1、判断是否获取锁的方式只需要判断有序节点中的序号最小的一个。当释放锁的时候，只需将这个瞬时节点删除即可。同时，其可以避免服务宕机导致的锁无法释放，而产生的死锁问题。
       * 2、提供的第三方库有curator，Curator提供的InterProcessMutex是分布式锁的实现。acquire方法获取锁，release方法获取锁。
       
* 基于缓存(redis)来实现分布式锁
    采用jedis.setnx()和jedis.expire()组合实现加锁。
    setnx()方法作用就是SET IF NOT EXIST，expire方法就是给锁加一个过期时间。由于这是两条Redis命令，不具有原子性，如果程序在执行完setnx()之后突然崩溃，导致锁没有设置过期时间。那么就会发生死锁。

二、synchronized作用于静态方法

  public class synchronizedTest implements Runnable {
      //共享资源
      static int i =0;
      /**
       * synchronized 修饰实例方法
       */
      public static synchronized void increase(){
          i++;
      }
      @Override
      public void run(){
          for (int j =0 ; j<10000;j++){
              increase();
          }
      }

      public static void main(String[] args) throws InterruptedException {
          Thread t1 = new Thread(new synchronizedTest());
          Thread t2 = new Thread(new synchronizedTest());
          t1.start();
          t2.start();
          t1.join();
          t2.join();
          System.out.println(i);
      }

运行结果：

分析：由例子可知，两个线程实例化两个不同的对象，但是访问的方法是静态的，两个线程发生了互斥（即一个线程访问，另一个线程只能等着），因为静态方法是依附于类而不是对象的，当synchronized修饰静态方法时，锁是class对象。

三、synchronized作用于同步代码块

为什么要同步代码块呢？在某些情况下，我们编写的方法体可能比较大，同时存在一些比较耗时的操作，而需要同步的代码又只有一小部分，如果直接对整个方法进行同步操作，可能会得不偿失，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，这样就无需对整个方法进行同步操作了。

   public class synchronizedTest implements Runnable {
      static synchronizedTest instance=new synchronizedTest();
      static int i=0;
      @Override
      public void run() {
          //省略其他耗时操作....
          //使用同步代码块对变量i进行同步操作,锁对象为instance
          synchronized(instance){
              for(int j=0;j<10000;j++){
                  i++;
              }
          }
      }
      public static void main(String[] args) throws InterruptedException {
          Thread t1=new Thread(instance);
          Thread t2=new Thread(instance);
          t1.start();
          t2.start();
          t1.join();
          t2.join();
          System.out.println(i);
      }
  }

运行结果：

分析：将synchronized作用于一个给定的实例对象instance，即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行i++;操作。当然除了instance作为对象外，我们还可以使用this对象(代表当前实例)或者当前类的class对象作为锁，如下代码：

    //this,当前实例对象锁
    synchronized(this){
        for(int j=0;j<1000000;j++){
            i++;
        }
    }

    //class对象锁
    synchronized(AccountingSync.class){
        for(int j=0;j<1000000;j++){
            i++;
        }
    }

转自
https://blog.csdn.net/m0_37834446/article/details/104493877
，并对内容加以补充

posted @ 2021-11-29 14:41 光一阅读(291) 评论(0) 编辑收藏举报

刷新页面返回顶部

光一

同步—Synchronized

1.为什么要使用synchronized

2.实现原理

3.synchronized的三种应用方式

4.synchronized的作用

5.举例子

公告