关于多线程:多线程2synchronized和volatile

多线程极大的晋升了效率，然而也带来了隐患，比方两个线程同时操作一个对象，就可能造成数据异样。

为什么会呈现线程平安问题

以下是一个线程不平安的程序，运行后果有时是10000，有时比10000小，而且每次都可能不同，这就是线程不平安，因为count++的操作不是原子性的，分为三步，读改写，即先读取数据，在执行批改操作（+1），再将数据回写到内存中，但这样就会呈现问题，比方线程一和线程二获取到了数据10，而后线程二进行批改和回写操作，将数据变为11，此时线程一开始执行，然而此时线程一读取到的数据还是10而部署线程二批改后的11，这样就会造成线程一和二各做一次减少操作，然而count从10变为了11，即产生了数据异样。

public class ThreadUnsafeDemo {

    private static int count;

    private static class Thread1 extends Thread {
        public void run() {
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        }
    }

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

}

那么为什么会呈现线程不平安问题，次要有三点

原子性：一个或者多个操作在 CPU 执行的过程中被中断(CPU上下文切换)
可见性：一个线程对共享变量的批改，另外一个线程不能立即看到
有序性：程序执行的程序没有依照代码的先后顺序执行
前两点后面曾经举例了，当初在解释一下第三点。为什么程序执行的程序会和代码的执行程序不统一呢？java平台包含两种编译器：动态编译器（javac）和动静编译器（jit:just in time）。动态编译器是将.java文件编译成.class文件（二进制文件），之后便能够解释执行。动静编译器是将.class文件编译成机器码，之后再由jvm运行。问题个别会呈现在动静编译器上，因为动静编译器为了程序的整体性能会对指令进行重排序，尽管重排序能够晋升程序的性能，然而重排序之后会导致源代码中指定的内存拜访程序与理论的执行程序不一样，就会呈现线程不平安的问题。

如何保障线程平安

针对原子性问题，JDK中有atomic类，这些类自身通过CAS保障操作的原子性。

针对可见性问题，能够通过synchronized关键字加锁来解决。与此同时，java还提供了一种轻量级的锁，即volatile关键字，要优于synchronized的性能，同样能够保障批改对其余线程的可见性。volatile个别用于对变量的写操作不依赖于以后值的场景中，比方状态标记量等。

针对有序性问题，能够通过synchronized关键字定义同步代码块或者同步办法保障有序性，另外也能够通过Lock接口保障有序性。

synchronized

Synchronized是Java中解决并发问题的一种最罕用的办法，也是最简略的一种办法。Synchronized的作用次要有三个：

原子性：确保线程互斥的拜访同步代码；
可见性：保障共享变量的批改可能及时可见，其实是通过Java内存模型中的 “对一个变量unlock操作之前，必须要同步到主内存中；如果对一个变量进行lock操作，则将会清空工作内存中此变量的值，在执行引擎应用此变量前，须要从新从主内存中load操作或assign操作初始化变量值” 来保障的；
有序性：无效解决重排序问题，即 “一个unlock操作后行产生(happen-before)于前面对同一个锁的lock操作”；

synchronized 内置锁是一种对象锁（锁的是对象而非援用变量），作用粒度是对象，能够用来实现对临界资源的同步互斥拜访，是可重入的。其最大的作用是防止死锁，如：

子类同步办法调用了父类同步办法，如没有可重入的个性，则会产生死锁；

对于synchronized办法或者synchronized代码块，当出现异常时，JVM会主动开释以后线程占用的锁，因而不会因为异样导致呈现死锁景象

应用办法

润饰办法

SynchronizedDemo润饰的是代码块，SynchronizedDemo1润饰的是办法，然而两者是等价的，都是锁定了对象，锁定了对象后对对象的操作只能期待上一个锁开释后进行

public class SynchronizedDemo {
    public void method() {
        synchronized (this) {
            System.out.println("Method 1 start");
        }
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.method();
    }
}

public class SynchronizedDemo1 {
    public synchronized void method() {
        System.out.println("Method 1 start");
    }

    public static void main(String[] args) {
        SynchronizedDemo1 synchronizedDemo = new SynchronizedDemo1();
        synchronizedDemo.method();
    }
}

润饰代码块

public class SynchronizedDemo2 {
    public static void main(String args[]) {
        SyncThread s1 = new SyncThread();
        SyncThread s2 = new SyncThread();
        Thread t1 = new Thread(s1);
        Thread t2 = new Thread(s2);

//        SyncThread s = new SyncThread();
//        Thread t1 = new Thread(s);
//        Thread t2 = new Thread(s);

        t1.start();
        t2.start();
    }

    static class SyncThread implements Runnable {
        private static int count;

        public SyncThread() {
            count = 0;
        }

        public void run() {
            synchronized (this) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println(Thread.currentThread().getName() + ":" + (count++));
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        public int getCount() {
            return count;
        }
    }
}

运行后果

因为实例化了两个SyncThread对象，各锁各的，导致计数异样，要实现管制须要对Class加锁

Thread-0:0
Thread-1:1
Thread-0:2
Thread-1:2
Thread-1:3
Thread-0:3
Thread-0:4
Thread-1:4
Thread-0:5
Thread-1:6

public class SynchronizedDemo2 {
    public static void main(String args[]) {
//        SyncThread s1 = new SyncThread();
//        SyncThread s2 = new SyncThread();
//        Thread t1 = new Thread(s1);
//        Thread t2 = new Thread(s2);

        SyncThread s = new SyncThread();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);

        t1.start();
        t2.start();
    }

    static class SyncThread implements Runnable {
        private static int count;

        public SyncThread() {
            count = 0;
        }

        public void run() {
            synchronized (this) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println(Thread.currentThread().getName() + ":" + (count++));
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        public int getCount() {
            return count;
        }
    }
}

运行后果

因为只实例化了一个SyncThread对象，当两个并发线程(thread1和thread2)拜访同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程失去执行，另一个线程受阻塞，必须期待以后线程执行完这个代码块当前能力执行该代码块。Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定以后的对象，只有执行完该代码块能力开释该对象锁，下一个线程能力执行并锁定该对象，所以计数正确

Thread-1:0
Thread-1:1
Thread-1:2
Thread-1:3
Thread-1:4
Thread-0:5
Thread-0:6
Thread-0:7
Thread-0:8
Thread-0:9

润饰局部代码块

public class SynchronizedDemo4 {
    public static void main(String args[]) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(counter, "A");
        Thread thread2 = new Thread(counter, "B");
        thread1.start();
        thread2.start();
    }

    static class Counter implements Runnable {
        private int count;

        public Counter() {
            count = 0;
        }

        public void countAdd() {
            synchronized (this) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println(Thread.currentThread().getName() + ":" + (count++));
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        //非synchronized代码块，未对count进行读写操作，所以能够不必synchronized
        public void printCount() {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + " count:" + count);
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public void run() {
            String threadName = Thread.currentThread().getName();
            if (threadName.equals("A")) {
                countAdd();
            } else if (threadName.equals("B")) {
                printCount();
            }
        }
    }
}

运行后果

B线程的调用是非synchronized,并不影响A线程对synchronized局部的调用。从下面的后果中能够看出一个线程拜访一个对象的synchronized代码块时，别的线程能够拜访该对象的非synchronized代码块而不受阻塞

A:0
B count:1
A:1
B count:1
A:2
B count:3
B count:3
A:3
B count:4
A:4

润饰指定对象

public class SynchronizedDemo3 {
    public static void main(String args[]) {
        Account account = new Account("zhang san", 10000.0f);
        AccountOperator accountOperator = new AccountOperator(account);
        //开启10个线程，进行存取款
        final int THREAD_NUM = 10;
        Thread threads[] = new Thread[THREAD_NUM];
        for (int i = 0; i < THREAD_NUM; i++) {
            threads[i] = new Thread(accountOperator, "Thread" + i);
            threads[i].start();
        }
    }

    static class Account {
        String name;
        float amount;

        public Account(String name, float amount) {
            this.name = name;
            this.amount = amount;
        }

        //存钱
        public void deposit(float amt) {
            amount += amt;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //取钱
        public void withdraw(float amt) {
            amount -= amt;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public float getBalance() {
            return amount;
        }
    }

    /**
     * 账户操作类
     */
    static class AccountOperator implements Runnable {
        private Account account;

        public AccountOperator(Account account) {
            this.account = account;
        }

        public void run() {
            //锁定指定对象account
            synchronized (account) {
                account.deposit(500);
                System.out.println("贷款实现" + Thread.currentThread().getName() + ":" + account.getBalance());
                account.withdraw(500);
                System.out.println("取款实现" + Thread.currentThread().getName() + ":" + account.getBalance());
            }
        }
    }
}

运行后果

在AccountOperator 类中的run办法里，咱们用synchronized 给account对象加了锁。这时，当一个线程拜访account对象时，其余试图拜访account对象的线程将会阻塞，直到该线程拜访account对象完结。也就是说谁拿到那个锁谁就能够运行它所管制的那段代码。

贷款实现Thread0:10500.0
取款实现Thread0:10000.0
贷款实现Thread9:10500.0
取款实现Thread9:10000.0
贷款实现Thread8:10500.0
取款实现Thread8:10000.0
贷款实现Thread5:10500.0
取款实现Thread5:10000.0
贷款实现Thread3:10500.0
取款实现Thread3:10000.0
贷款实现Thread7:10500.0
取款实现Thread7:10000.0
贷款实现Thread6:10500.0
取款实现Thread6:10000.0
贷款实现Thread4:10500.0
取款实现Thread4:10000.0
贷款实现Thread2:10500.0
取款实现Thread2:10000.0
贷款实现Thread1:10500.0
取款实现Thread1:10000.0

润饰静态方法

public class SynchronizedDemo5 {
    public static void main(String args[]) {
        SyncThread syncThread1 = new SyncThread();
        SyncThread syncThread2 = new SyncThread();
        Thread thread1 = new Thread(syncThread1, "SyncThread1");
        Thread thread2 = new Thread(syncThread2, "SyncThread2");
        thread1.start();
        thread2.start();
    }

    static class SyncThread implements Runnable {
        private static int count;

        public SyncThread() {
            count = 0;
        }

        public synchronized static void method() {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public synchronized void run() {
            method();
        }
    }
}

运行后果

syncThread1和syncThread2是SyncThread的两个对象，但在thread1和thread2并发执行时却放弃了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于用了同一把锁。

SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9

润饰一个类

public class SynchronizedDemo6 {
    public static void main(String args[]) {
        SyncThread syncThread1 = new SyncThread();
        SyncThread syncThread2 = new SyncThread();
        Thread thread1 = new Thread(syncThread1, "SyncThread1");
        Thread thread2 = new Thread(syncThread2, "SyncThread2");
        thread1.start();
        thread2.start();
    }

    static class SyncThread implements Runnable {
        private static int count;

        public SyncThread() {
            count = 0;
        }

        public static void method() {
            synchronized (SyncThread.class) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println(Thread.currentThread().getName() + ":" + (count++));
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        public synchronized void run() {
            method();
        }
    }
}

运行后果

给class加锁和上例的给静态方法加锁是一样的，所有对象专用一把锁，保障程序输入

SyncThread2:0
SyncThread2:1
SyncThread2:2
SyncThread2:3
SyncThread2:4
SyncThread1:5
SyncThread1:6
SyncThread1:7
SyncThread1:8
SyncThread1:9

应用总结

当synchronized作用在实例办法时，监视器锁（monitor）便是对象实例（this），即以后实例，然而如果创立了多个实例，各锁各的就无法控制输入；
当synchronized作用在某一个对象实例时，监视器锁（monitor）便是括号括起来的对象实例；
当synchronized作用在静态方法时，监视器锁（monitor）便是对象的Class实例，因为Class数据存在于永恒代，因而静态方法锁相当于该类的一个全局锁；
每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就能够运行它所管制的那段代码。
实现同步开销微小，甚至可能造成死锁，所以尽量避免无谓的同步控制。

实现原理

执行SynchronizedDemo后，查看字节码

Compiled from "SynchronizedDemo.java"
public class com.example.offer.thread.demo3.SynchronizedDemo {
  public com.example.offer.thread.demo3.SynchronizedDemo();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public void method();
    Code:
       0: aload_0
       1: dup
       2: astore_1
       3: monitorenter
       4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       7: ldc           #3                  // String Method 1 start
       9: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      12: aload_1
      13: monitorexit
      14: goto          22
      17: astore_2
      18: aload_1
      19: monitorexit
      20: aload_2
      21: athrow
      22: return
    Exception table:
       from    to  target type
           4    14    17   any
          17    20    17   any

  public static void main(java.lang.String[]);
    Code:
       0: new           #5                  // class com/example/offer/thread/demo3/SynchronizedDemo
       3: dup
       4: invokespecial #6                  // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: invokevirtual #7                  // Method method:()V
      12: return
}

重点是其中的monitorenter和monitorexit

monitorenter：每个对象都是一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：
1. 如果monitor的进入数为0，则该线程进入monitor，而后将进入数设置为1，该线程即为monitor的所有者；
2. 如果线程曾经占有该monitor，只是从新进入，则进入monitor的进入数加1；
3. 如果其余线程曾经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再从新尝试获取monitor的所有权；
monitorexit：执行monitorexit的线程必须是objectref所对应的monitor的所有者。指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其余被这个monitor阻塞的线程能够尝试去获取这个 monitor 的所有权。

monitorexit指令呈现了两次，第1次为同步失常退出开释锁；第2次为产生异步退出开释锁；

通过下面两段形容，咱们应该能很分明的看出Synchronized的实现原理，Synchronized的语义底层是通过一个monitor的对象来实现，其实wait/notify等办法也依赖于monitor对象，这就是为什么只有在同步的块或者办法中能力调用wait/notify等办法，否则会抛出java.lang.IllegalMonitorStateException的异样的起因。

volatile

volatile关键字的作用：保障了变量的可见性（visibility）。被volatile关键字润饰的变量，如果值产生了变更，其余线程立马可见，避免出现脏读的景象，volatile实质是在通知jvm以后变量在寄存器（工作内存）中的值是不确定的，须要从主存中读取，volatile仅能应用在变量级别

synchronized关键字是避免多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些状况下性能要优于synchronized，然而要留神volatile关键字是无奈代替synchronized关键字的，因为volatile关键字无奈保障操作的原子性。通常来说，应用volatile必须具备以下2个条件：

　　1）对变量的写操作不依赖于以后值

　　2）该变量没有蕴含在具备其余变量的不变式中

实际上，这些条件表明，能够被写入 volatile 变量的这些有效值独立于任何程序的状态，包含变量的以后状态。

事实上，我的了解就是下面的2个条件须要保障操作是原子性操作，能力保障应用volatile关键字的程序在并发时可能正确执行。

应用场景

状态标记

volatile boolean inited = false;
//线程1:
context = loadContext();  
inited = true;            
 
//线程2:
while(!inited ){
sleep()
}
doSomethingwithconfig(context);

双重校验

第一次校验：因为单例模式只须要创立一次实例，如果前面再次调用getInstance办法时，则间接返回之前创立的实例，因而大部分工夫不须要执行同步办法外面的代码，大大提高了性能。如果不加第一次校验的话，那跟下面的懒汉模式没什么区别，每次都要去竞争锁。

第二次校验：如果没有第二次校验，假如线程t1执行了第一次校验后，判断为null，这时t2也获取了CPU执行权，也执行了第一次校验，判断也为null。接下来t2取得锁，创立实例。这时t1又取得CPU执行权，因为之前曾经进行了第一次校验，后果为null（不会再次判断），取得锁后，间接创立实例。后果就会导致创立多个实例。所以须要在同步代码外面进行第二次校验，如果实例为空，则进行创立。

须要留神的是，private volatile static Singleton instance = null;须要加volatile关键字，否则会呈现谬误。问题的起因在于JVM指令重排优化的存在。在某个线程创立单例对象时，在构造方法被调用之前，就为该对象调配了内存空间并将对象的字段设置为默认值。此时就能够将调配的内存地址赋值给instance字段了，然而该对象可能还没有初始化。若紧接着另外一个线程来调用getInstance，取到的就是状态不正确的对象，程序就会出错，所以须要volatile禁止指令重排序优化。

instance = new Singleton();中new命令并不是一个原子指令，它分为三步

调配对象内存

调用结构器办法，执行初始化

将对象援用赋值给变量

虚拟机理论运行时，以上指令可能产生重排序。以上代码 2,3 可能产生重排序，然而并不会重排序 1 的程序。也就是说 1 这个指令都须要先执行，因为 2,3 指令须要依靠 1 指令执行后果。

Java 语言规规定了线程执行程序时须要恪守 intra-thread semantics。intra-thread semantics 保障重排序不会扭转单线程内的程序执行后果。这个重排序在没有扭转单线程程序的执行后果的前提下，能够进步程序的执行性能。

尽管重排序并不影响单线程内的执行后果，然而在多线程的环境就带来一些问题。

class Singleton{
    private volatile static Singleton instance = null;
     
    private Singleton() {
         
    }
     
    public static Singleton getInstance() {
        if(instance==null) {
            synchronized (Singleton.class) {
                if(instance==null)
                    instance = new Singleton();
            }
        }
        return instance;
    }
}

应用办法

润饰变量

public class VolatileDemo {

    private static int count;

    public static void main(String args[]) {
        SyncThread s = new SyncThread();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);

        t1.start();
        t2.start();
    }

    static class SyncThread implements Runnable {
        public SyncThread() {
            count = 0;
        }
        public void run() {
            synchronized (this) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println(Thread.currentThread().getName() + ":" + (count++));
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        public int getCount() {
            return count;
        }
    }
}

运行后果

Thread-0:0
Thread-1:1
Thread-0:2
Thread-1:3
Thread-0:4
Thread-1:5
Thread-0:6
Thread-1:7
Thread-0:8
Thread-1:9

应用总结

一旦一个共享变量（类的成员变量、类的动态成员变量）被volatile润饰之后，那么就具备了两层语义：
1）保障了不同线程对这个变量进行操作时的可见性，即一个线程批改了某个变量的值，这新值对其余线程来说是
立刻可见的。
2）禁止进行指令重排序。
volatile实质是在通知jvm以后变量在寄存器（工作内存）中的值是不确定的，须要从主存中读取；
synchronized则是锁定以后变量，只有以后线程能够拜访该变量，其余线程被阻塞住。

实现原理

有volatile变量润饰的共享变量进行操作时会减少一行汇编命令，命令有前缀lock，而lock前缀的指令在多核处理器中会触发以下两件事件

将以后处理器缓存的数据回写到主内存
回写主内存操作会引起其余CPU中缓存了该内存地址的数据有效

synchronized和volatile的区别

1.volatile仅能应用在变量级别；
synchronized则能够应用在变量、办法、和类级别的

2.volatile仅能实现变量的批改可见性，并不能保障原子性；

synchronized则能够保障变量的批改可见性和原子性

3.volatile不会造成线程的阻塞；
synchronized可能会造成线程的阻塞。

4.volatile标记的变量不会被编译器优化；
synchronized标记的变量能够被编译器优化

关于多线程:多线程2synchronized和volatile

为什么会呈现线程平安问题

如何保障线程平安

synchronized

应用办法

润饰办法

润饰代码块

润饰局部代码块

润饰指定对象

润饰静态方法

润饰一个类

应用总结

实现原理

volatile

应用场景

状态标记

双重校验

应用办法

润饰变量

应用总结

实现原理

synchronized和volatile的区别

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于多线程:多线程2synchronized和volatile

为什么会呈现线程平安问题

如何保障线程平安

synchronized

应用办法

润饰办法

润饰代码块

润饰局部代码块

润饰指定对象

润饰静态方法

润饰一个类

应用总结

实现原理

volatile

应用场景

状态标记

双重校验

应用办法

润饰变量

应用总结

实现原理

synchronized和volatile的区别

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复